diff --git a/.circleci/soltest.sh b/.circleci/soltest.sh
index 71c2a952adac..c924e3ed6bcb 100755
--- a/.circleci/soltest.sh
+++ b/.circleci/soltest.sh
@@ -43,22 +43,6 @@ REPODIR="$(realpath "$(dirname "$0")/..")"
 IFS=" " read -r -a BOOST_TEST_ARGS <<< "$BOOST_TEST_ARGS"
 IFS=" " read -r -a SOLTEST_FLAGS <<< "$SOLTEST_FLAGS"
 
-# TODO: [EOF] These won't pass on EOF yet. Reenable them when the implementation is complete.
-EOF_EXCLUDES=(
-    --run_test='!Assembler/all_assembly_items'
-    --run_test='!Assembler/immutable'
-    --run_test='!Assembler/immutables_and_its_source_maps'
-    --run_test='!Optimiser/jumpdest_removal_subassemblies'
-    --run_test='!Optimiser/jumpdest_removal_subassemblies/*'
-    --run_test='!SolidityCompiler/does_not_include_creation_time_only_internal_functions'
-    --run_test='!SolidityInlineAssembly/Analysis/create2'
-    --run_test='!SolidityInlineAssembly/Analysis/inline_assembly_shadowed_instruction_declaration'
-    --run_test='!SolidityInlineAssembly/Analysis/large_constant'
-    --run_test='!SolidityInlineAssembly/Analysis/staticcall'
-    --run_test='!ViewPureChecker/assembly_staticcall'
-    --run_test='!yulStackLayout/literal_loop'
-)
-
 # shellcheck source=scripts/common.sh
 source "${REPODIR}/scripts/common.sh"
 # Test result output directory (CircleCI is reading test results from here)
@@ -96,7 +80,6 @@ do
         "--logger=HRF,error,stdout"
         "${BOOST_TEST_ARGS[@]}"
     )
-    (( EOF_VERSION != 0 )) && BOOST_TEST_ARGS_RUN+=("${EOF_EXCLUDES[@]}")
     SOLTEST_ARGS=("--evm-version=$EVM" "${SOLTEST_FLAGS[@]}")
 
     test "${OPTIMIZE}" = "1" && SOLTEST_ARGS+=(--optimize)
diff --git a/test/Common.cpp b/test/Common.cpp
index 43f73d4d71d4..30738dcfc6dd 100644
--- a/test/Common.cpp
+++ b/test/Common.cpp
@@ -302,6 +302,13 @@ bool isValidSemanticTestPath(boost::filesystem::path const& _testPath)
 	return true;
 }
 
+boost::unit_test::precondition::predicate_t nonEOF()
+{
+	return [](boost::unit_test::test_unit_id) {
+		return !solidity::test::CommonOptions::get().eofVersion().has_value();
+	};
+}
+
 boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVersion _minEVMVersion)
 {
 	return [_minEVMVersion](boost::unit_test::test_unit_id) {
diff --git a/test/Common.h b/test/Common.h
index c3d21d258295..866f6945a645 100644
--- a/test/Common.h
+++ b/test/Common.h
@@ -112,6 +112,10 @@ bool isValidSemanticTestPath(boost::filesystem::path const& _testPath);
 /// @return A predicate (function) that can be passed into @a boost::unit_test::precondition().
 boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVersion _minEVMVersion);
 
+/// Helper that can be used to skip tests when the EOF is not supported by the test case.
+/// @return A predicate (function) that can be passed into @a boost::unit_test::precondition().
+boost::unit_test::precondition::predicate_t nonEOF();
+
 bool loadVMs(CommonOptions const& _options);
 
 /**
diff --git a/test/TestCase.cpp b/test/TestCase.cpp
index 9505a2caafe5..104bd1bdeefb 100644
--- a/test/TestCase.cpp
+++ b/test/TestCase.cpp
@@ -150,7 +150,7 @@ void EVMVersionRestrictedTestCase::processBytecodeFormatSetting()
 	// EOF only available since Prague
 	solAssert(!eofVersion.has_value() ||solidity::test::CommonOptions::get().evmVersion() >= langutil::EVMVersion::prague());
 
-	std::string bytecodeFormatString = m_reader.stringSetting("bytecodeFormat", "legacy");
+	std::string bytecodeFormatString = m_reader.stringSetting("bytecodeFormat", "legacy,>=EOFv1");
 	if (bytecodeFormatString == "legacy,>=EOFv1" || bytecodeFormatString == ">=EOFv1,legacy")
 		return;
 
diff --git a/test/libevmasm/Assembler.cpp b/test/libevmasm/Assembler.cpp
index b1222b49d1ae..3a6383002dc3 100644
--- a/test/libevmasm/Assembler.cpp
+++ b/test/libevmasm/Assembler.cpp
@@ -37,6 +37,7 @@
 
 using namespace solidity::langutil;
 using namespace solidity::evmasm;
+using namespace solidity::test;
 using namespace std::string_literals;
 
 namespace solidity::frontend::test
@@ -54,7 +55,7 @@ namespace
 
 BOOST_AUTO_TEST_SUITE(Assembler)
 
-BOOST_AUTO_TEST_CASE(all_assembly_items)
+BOOST_AUTO_TEST_CASE(all_assembly_items, *boost::unit_test::precondition(nonEOF()))
 {
 	std::map<std::string, unsigned> indices = {
 		{ "root.asm", 0 },
@@ -216,7 +217,8 @@ BOOST_AUTO_TEST_CASE(all_assembly_items)
 	BOOST_CHECK_EQUAL(util::jsonCompactPrint(_assembly.assemblyJSON(indices)), util::jsonCompactPrint(jsonValue));
 }
 
-BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
+// TODO: Implement EOF counterpart
+BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps, *boost::unit_test::precondition(nonEOF()))
 {
 	EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
 	// Tests for 1, 2, 3 number of immutables.
@@ -301,7 +303,8 @@ BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
 	}
 }
 
-BOOST_AUTO_TEST_CASE(immutable)
+// TODO: Implement EOF counterpart
+BOOST_AUTO_TEST_CASE(immutable, *boost::unit_test::precondition(nonEOF()))
 {
 	std::map<std::string, unsigned> indices = {
 		{ "root.asm", 0 },
diff --git a/test/libevmasm/Optimiser.cpp b/test/libevmasm/Optimiser.cpp
index 8ed413cfe199..9a7bd0636b0f 100644
--- a/test/libevmasm/Optimiser.cpp
+++ b/test/libevmasm/Optimiser.cpp
@@ -41,6 +41,7 @@
 
 using namespace solidity::langutil;
 using namespace solidity::evmasm;
+using namespace solidity::test;
 
 namespace solidity::frontend::test
 {
@@ -1329,7 +1330,7 @@ BOOST_AUTO_TEST_CASE(jumpdest_removal)
 	);
 }
 
-BOOST_AUTO_TEST_CASE(jumpdest_removal_subassemblies)
+BOOST_AUTO_TEST_CASE(jumpdest_removal_subassemblies, *boost::unit_test::precondition(nonEOF()))
 {
 	// This tests that tags from subassemblies are not removed
 	// if they are referenced by a super-assembly. Furthermore,
@@ -1346,7 +1347,7 @@ BOOST_AUTO_TEST_CASE(jumpdest_removal_subassemblies)
 	settings.evmVersion = solidity::test::CommonOptions::get().evmVersion();
 	settings.expectedExecutionsPerDeployment = OptimiserSettings{}.expectedExecutionsPerDeployment;
 
-	Assembly main{settings.evmVersion, false, solidity::test::CommonOptions::get().eofVersion(), {}};
+	Assembly main{settings.evmVersion, false, std::nullopt, {}};
 	AssemblyPointer sub = std::make_shared<Assembly>(settings.evmVersion, true, solidity::test::CommonOptions::get().eofVersion(), std::string{});
 
 	sub->append(u256(1));
diff --git a/test/libsolidity/InlineAssembly.cpp b/test/libsolidity/InlineAssembly.cpp
index b3993e39f3df..fb08c667ce54 100644
--- a/test/libsolidity/InlineAssembly.cpp
+++ b/test/libsolidity/InlineAssembly.cpp
@@ -44,6 +44,7 @@
 
 using namespace solidity::langutil;
 using namespace solidity::yul;
+using namespace solidity::test;
 
 namespace solidity::frontend::test
 {
@@ -294,7 +295,8 @@ BOOST_AUTO_TEST_CASE(designated_invalid_instruction)
 	BOOST_CHECK(successAssemble("{ invalid() }"));
 }
 
-BOOST_AUTO_TEST_CASE(inline_assembly_shadowed_instruction_declaration)
+// TODO: Implement EOF counterpart
+BOOST_AUTO_TEST_CASE(inline_assembly_shadowed_instruction_declaration, *boost::unit_test::precondition(nonEOF()))
 {
 	CHECK_ASSEMBLE_ERROR("{ let gas := 1 }", ParserError, "Cannot use builtin");
 }
@@ -333,14 +335,14 @@ BOOST_AUTO_TEST_CASE(returndatacopy)
 	BOOST_CHECK(successAssemble("{ returndatacopy(0, 32, 64) }"));
 }
 
-BOOST_AUTO_TEST_CASE(staticcall)
+BOOST_AUTO_TEST_CASE(staticcall, *boost::unit_test::precondition(nonEOF()))
 {
 	if (!solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
 		return;
 	BOOST_CHECK(successAssemble("{ pop(staticcall(10000, 0x123, 64, 0x10, 128, 0x10)) }"));
 }
 
-BOOST_AUTO_TEST_CASE(create2)
+BOOST_AUTO_TEST_CASE(create2, *boost::unit_test::precondition(nonEOF()))
 {
 	if (!solidity::test::CommonOptions::get().evmVersion().hasCreate2())
 		return;
diff --git a/test/libsolidity/Metadata.cpp b/test/libsolidity/Metadata.cpp
index ed490b9a839b..9c0fba3e1447 100644
--- a/test/libsolidity/Metadata.cpp
+++ b/test/libsolidity/Metadata.cpp
@@ -225,6 +225,45 @@ BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
 		}
 }
 
+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(langutil::EVMVersion::prague());
+		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;
diff --git a/test/libsolidity/SMTCheckerTest.cpp b/test/libsolidity/SMTCheckerTest.cpp
index c25025ccf77c..1874f6a523dc 100644
--- a/test/libsolidity/SMTCheckerTest.cpp
+++ b/test/libsolidity/SMTCheckerTest.cpp
@@ -136,6 +136,9 @@ SMTCheckerTest::SMTCheckerTest(std::string const& _filename):
 
 	auto const& bmcLoopIterations = m_reader.sizetSetting("BMCLoopIterations", 1);
 	m_modelCheckerSettings.bmcLoopIterations = std::optional<unsigned>{bmcLoopIterations};
+
+	if (m_evmVersion < langutil::EVMVersion::prague() && CommonOptions::get().eofVersion().has_value())
+		m_shouldRun = false;
 }
 
 void SMTCheckerTest::setupCompiler(CompilerStack& _compiler)
diff --git a/test/libsolidity/SolidityCompiler.cpp b/test/libsolidity/SolidityCompiler.cpp
index 7cb95a99d0bc..79d838349af9 100644
--- a/test/libsolidity/SolidityCompiler.cpp
+++ b/test/libsolidity/SolidityCompiler.cpp
@@ -24,6 +24,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+using namespace solidity::test;
 
 namespace solidity::frontend::test
 {
@@ -42,7 +43,8 @@ class SolidityCompilerFixture: protected AnalysisFramework
 
 BOOST_FIXTURE_TEST_SUITE(SolidityCompiler, SolidityCompilerFixture)
 
-BOOST_AUTO_TEST_CASE(does_not_include_creation_time_only_internal_functions)
+// TODO: Implement EOF counterpart
+BOOST_AUTO_TEST_CASE(does_not_include_creation_time_only_internal_functions, *boost::unit_test::precondition(nonEOF()))
 {
 	char const* sourceCode = R"(
 		contract C {
diff --git a/test/libsolidity/SyntaxTest.cpp b/test/libsolidity/SyntaxTest.cpp
index 41c1d0568be6..4fd3df7cfc6f 100644
--- a/test/libsolidity/SyntaxTest.cpp
+++ b/test/libsolidity/SyntaxTest.cpp
@@ -48,7 +48,9 @@ SyntaxTest::SyntaxTest(
 {
 	static std::set<std::string> const compileViaYulAllowedValues{"true", "false"};
 
-	m_compileViaYul = m_reader.stringSetting("compileViaYul", "false");
+	auto const eofEnabled = solidity::test::CommonOptions::get().eofVersion().has_value();
+
+	m_compileViaYul = m_reader.stringSetting("compileViaYul", eofEnabled ? "true" : "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);
diff --git a/test/libsolidity/ViewPureChecker.cpp b/test/libsolidity/ViewPureChecker.cpp
index 3d0e024da83b..ac220283a8e6 100644
--- a/test/libsolidity/ViewPureChecker.cpp
+++ b/test/libsolidity/ViewPureChecker.cpp
@@ -28,6 +28,7 @@
 #include <tuple>
 
 using namespace solidity::langutil;
+using namespace solidity::test;
 
 namespace solidity::frontend::test
 {
@@ -133,7 +134,7 @@ BOOST_AUTO_TEST_CASE(address_staticcall)
 }
 
 
-BOOST_AUTO_TEST_CASE(assembly_staticcall)
+BOOST_AUTO_TEST_CASE(assembly_staticcall, *boost::unit_test::precondition(nonEOF()))
 {
 	std::string text = R"(
 		contract C {
diff --git a/test/libsolidity/semanticTests/builtinFunctions/eof/keccak256_packed_complex_types.sol b/test/libsolidity/semanticTests/builtinFunctions/eof/keccak256_packed_complex_types.sol
new file mode 100644
index 000000000000..70c4b4f62ad2
--- /dev/null
+++ b/test/libsolidity/semanticTests/builtinFunctions/eof/keccak256_packed_complex_types.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint120[3] x;
+    function f() public returns (bytes32 hash1, bytes32 hash2, bool hash3NonZero) {
+        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));
+        hash3NonZero = bytes32(0) != keccak256(abi.encodePacked(this.f));
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f() -> 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, true
diff --git a/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol b/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol
index ea6d781898f0..91cdde3adcf6 100644
--- a/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol
+++ b/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol
@@ -10,5 +10,7 @@ contract C {
         hash3 = keccak256(abi.encodePacked(this.f));
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0x0e9229fb1d2cd02cee4b6c9f25497777014a8766e3479666d1c619066d2887ec
diff --git a/test/libsolidity/semanticTests/constructor/callvalue_check.sol b/test/libsolidity/semanticTests/constructor/callvalue_check.sol
index f45fbed925ad..5088fd399d3c 100644
--- a/test/libsolidity/semanticTests/constructor/callvalue_check.sol
+++ b/test/libsolidity/semanticTests/constructor/callvalue_check.sol
@@ -29,6 +29,7 @@ contract C {
 }
 // ====
 // EVMVersion: >homestead
+// bytecodeFormat: legacy
 // ----
 // f(uint256), 2000 ether: 0 -> true
 // f(uint256), 2000 ether: 100 -> false
diff --git a/test/libsolidity/semanticTests/constructor/eof/no_callvalue_check.sol b/test/libsolidity/semanticTests/constructor/eof/no_callvalue_check.sol
new file mode 100644
index 000000000000..9869005cd01e
--- /dev/null
+++ b/test/libsolidity/semanticTests/constructor/eof/no_callvalue_check.sol
@@ -0,0 +1,28 @@
+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, salt: hex"00"}();
+		new B2{value: 10, salt: hex"01"}();
+		new B3{value: 10, salt: hex"02"}();
+		return true;
+	}
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f(), 2000 ether -> true
+// gas irOptimized: 117623
+// gas irOptimized code: 1800
+// gas legacy: 117821
+// gas legacy code: 4800
+// gas legacyOptimized: 117690
+// gas legacyOptimized code: 4800
diff --git a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol
index 583f1ca37b3f..a1d3c290958b 100644
--- a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol
+++ b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol
@@ -15,6 +15,8 @@ contract C {
 		return true;
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f(), 2000 ether -> true
 // gas irOptimized: 117623
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol
index 64b80422c352..0fadadf0e877 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol
@@ -36,5 +36,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol
index 931109199649..65ca40d83c8e 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol
@@ -30,5 +30,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol
index 018d410557b0..6ec0ee755257 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol
@@ -32,5 +32,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol
index 0f9b023b08d9..089a4d33658a 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol
@@ -31,5 +31,7 @@ contract C is S {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol
index b6ae85b838d8..f0d5677bcfb5 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol
@@ -37,5 +37,7 @@ contract C {
             x < 2 * type(A).creationCode.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol
index 9accc54a2b05..941e4cf4869c 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol
@@ -31,5 +31,7 @@ contract C is S {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol b/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol
index 866fe9dfc452..83ddf048f365 100644
--- a/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol
+++ b/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol
@@ -35,5 +35,7 @@ contract C is X {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true
diff --git a/test/libsolidity/semanticTests/eof/interface_inheritance_conversions.sol b/test/libsolidity/semanticTests/eof/interface_inheritance_conversions.sol
new file mode 100644
index 000000000000..d69337fc0cca
--- /dev/null
+++ b/test/libsolidity/semanticTests/eof/interface_inheritance_conversions.sol
@@ -0,0 +1,47 @@
+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) {
+        bytes32 s = 0x0000000000000000000000000000000000000000000000000000000000000001;
+        SubA sa = new Impl{salt: s}();
+        return (sa.parentFun(), sa.subAFun());
+    }
+
+    function convertSubB() public returns (uint256, uint256) {
+        bytes32 s = 0x0000000000000000000000000000000000000000000000000000000000000002;
+        SubB sb = new Impl{salt: s}();
+        return (sb.parentFun(), sb.subBFun());
+    }
+}
+// ====
+// bytecodeFormat: legacy
+// ----
+// 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/test/libsolidity/semanticTests/errors/eof/errors_by_parameter_type.sol b/test/libsolidity/semanticTests/errors/eof/errors_by_parameter_type.sol
new file mode 100644
index 000000000000..ce183eba2c1d
--- /dev/null
+++ b/test/libsolidity/semanticTests/errors/eof/errors_by_parameter_type.sol
@@ -0,0 +1,46 @@
+pragma abicoder v2;
+
+struct S {
+    uint256 a;
+    bool b;
+    string s;
+}
+
+error E();
+error E1(uint256);
+error E2(string);
+error E3(S);
+error E4(address);
+error E5(function() external pure);
+
+contract C {
+    function a() external pure {
+        require(false, E());
+    }
+    function b() external pure {
+        require(false, E1(1));
+    }
+    function c() external pure {
+        require(false, E2("string literal"));
+    }
+    function d() external pure {
+        require(false, E3(S(1, true, "string literal")));
+    }
+    function e() external view {
+        require(false, E4(address(0x6AfCA7D4Df015A0Ba25dA0d02D175603a5fB40E6)));
+    }
+    function f(function() external pure x) external view {
+        require(false, E5(x));
+    }
+}
+
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// a() -> FAILURE, hex"92bbf6e8"
+// b() -> FAILURE, hex"47e26897", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// c() -> FAILURE, hex"8f372c34", hex"0000000000000000000000000000000000000000000000000000000000000020", hex"000000000000000000000000000000000000000000000000000000000000000e", hex"737472696e67206c69746572616c000000000000000000000000000000000000"
+// d() -> FAILURE, hex"5717173e", hex"0000000000000000000000000000000000000000000000000000000000000020", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"000000000000000000000000000000000000000000000000000000000000000e", hex"737472696e67206c69746572616c000000000000000000000000000000000000"
+// e() -> FAILURE, hex"7efef9ea", hex"0000000000000000000000006afca7d4df015a0ba25da0d02d175603a5fb40e6"
+// f(function): left(0x6afca7d4df015a0ba25da0d02d175603a5fb40e60dbe671f0000000000000000) -> FAILURE, hex"0c3f12eb", hex"6afca7d4df015a0ba25da0d02d175603a5fb40e60dbe671f0000000000000000"
diff --git a/test/libsolidity/semanticTests/errors/eof/require_error_function_pointer_parameter.sol b/test/libsolidity/semanticTests/errors/eof/require_error_function_pointer_parameter.sol
new file mode 100644
index 000000000000..eac8c36f8f7c
--- /dev/null
+++ b/test/libsolidity/semanticTests/errors/eof/require_error_function_pointer_parameter.sol
@@ -0,0 +1,16 @@
+error CustomError(function(uint256) external pure returns (uint256));
+
+contract C
+{
+    function f(function(uint256) external pure returns (uint256) x) external view
+    {
+        // more than one stack slot
+        require(false, CustomError(x));
+    }
+}
+
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f(function): left(0xa4dc3b5fce39438ce512c732ccb22e3212856bb6f37cdc8e0000000000000000) -> FAILURE, hex"271b1dfa", hex"a4dc3b5fce39438ce512c732ccb22e3212856bb6f37cdc8e0000000000000000"
diff --git a/test/libsolidity/semanticTests/errors/errors_by_parameter_type.sol b/test/libsolidity/semanticTests/errors/errors_by_parameter_type.sol
index bc70b5bef757..19697444efeb 100644
--- a/test/libsolidity/semanticTests/errors/errors_by_parameter_type.sol
+++ b/test/libsolidity/semanticTests/errors/errors_by_parameter_type.sol
@@ -36,6 +36,7 @@ contract C {
 
 // ====
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // a() -> FAILURE, hex"92bbf6e8"
 // b() -> FAILURE, hex"47e26897", hex"0000000000000000000000000000000000000000000000000000000000000001"
diff --git a/test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol b/test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol
index 3af19ca64fbf..dd4376dbb3b2 100644
--- a/test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol
+++ b/test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol
@@ -14,5 +14,7 @@ contract C
     }
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> FAILURE, hex"271b1dfa", hex"c06afe3a8444fc0004668591e8306bfb9968e79ef37cdc8e0000000000000000"
diff --git a/test/libsolidity/semanticTests/events/eof/event_indexed_function.sol b/test/libsolidity/semanticTests/events/eof/event_indexed_function.sol
new file mode 100644
index 000000000000..3a92a43699a4
--- /dev/null
+++ b/test/libsolidity/semanticTests/events/eof/event_indexed_function.sol
@@ -0,0 +1,12 @@
+contract C {
+    event Test(function() external indexed);
+    function f(function() external x) public {
+        emit Test(x);
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f(function): left(0x8f8cc95dcbe7358c1cf1409d3a7ad079e89576bb26121ff00000000000000000) ->
+// ~ emit Test(function): #0x8f8cc95dcbe7358c1cf1409d3a7ad079e89576bb26121ff00000000000000000
diff --git a/test/libsolidity/semanticTests/events/eof/event_indexed_function2.sol b/test/libsolidity/semanticTests/events/eof/event_indexed_function2.sol
new file mode 100644
index 000000000000..a73f51d2846e
--- /dev/null
+++ b/test/libsolidity/semanticTests/events/eof/event_indexed_function2.sol
@@ -0,0 +1,18 @@
+contract C {
+    event TestA(function() external indexed);
+    event TestB(function(uint256) external indexed);
+    function f1(function() external x) public {
+        emit TestA(x);
+    }
+    function f2(function(uint256) external x) public {
+        emit TestB(x);
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f1(function): left(0x347eaa94e3f63220b1f27af5888d33325ddbd4dec27fc3050000000000000000) ->
+// ~ emit TestA(function): #0x347eaa94e3f63220b1f27af5888d33325ddbd4dec27fc3050000000000000000
+// f2(function): left(0x347eaa94e3f63220b1f27af5888d33325ddbd4debf3724af0000000000000000) ->
+// ~ emit TestB(function): #0x347eaa94e3f63220b1f27af5888d33325ddbd4debf3724af0000000000000000
diff --git a/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol b/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol
index 61e1bbdd6c0e..4bde7265523f 100644
--- a/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol
+++ b/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol
@@ -13,6 +13,8 @@ contract C {
         d.deposit(_id);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor() ->
 // gas irOptimized: 113970
diff --git a/test/libsolidity/semanticTests/events/event_indexed_function.sol b/test/libsolidity/semanticTests/events/event_indexed_function.sol
index ea7574159500..995295796a83 100644
--- a/test/libsolidity/semanticTests/events/event_indexed_function.sol
+++ b/test/libsolidity/semanticTests/events/event_indexed_function.sol
@@ -4,6 +4,8 @@ contract C {
         emit Test(this.f);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() ->
 // ~ emit Test(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79e26121ff00000000000000000
diff --git a/test/libsolidity/semanticTests/events/event_indexed_function2.sol b/test/libsolidity/semanticTests/events/event_indexed_function2.sol
index d4c47e868a1f..06b4c9eb5d32 100644
--- a/test/libsolidity/semanticTests/events/event_indexed_function2.sol
+++ b/test/libsolidity/semanticTests/events/event_indexed_function2.sol
@@ -8,6 +8,8 @@ contract C {
         emit TestB(this.f2);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f1() ->
 // ~ emit TestA(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79ec27fc3050000000000000000
diff --git a/test/libsolidity/semanticTests/experimental/stub.sol b/test/libsolidity/semanticTests/experimental/stub.sol
index 6e7a750fe980..d2d0999bfb76 100644
--- a/test/libsolidity/semanticTests/experimental/stub.sol
+++ b/test/libsolidity/semanticTests/experimental/stub.sol
@@ -92,6 +92,7 @@ contract C {
 // EVMVersion: >=constantinople
 // ====
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // (): 0 -> 0
 // (): 1 -> 544
diff --git a/test/libsolidity/semanticTests/experimental/type_class.sol b/test/libsolidity/semanticTests/experimental/type_class.sol
index 69fa568dfd96..7331c0dbd73c 100644
--- a/test/libsolidity/semanticTests/experimental/type_class.sol
+++ b/test/libsolidity/semanticTests/experimental/type_class.sol
@@ -63,5 +63,6 @@ contract C {
 // ====
 // EVMVersion: >=constantinople
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // () -> 1, 0
diff --git a/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol b/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol
index c53e49f1f032..c0bf36f0cabc 100644
--- a/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol
+++ b/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol
@@ -174,6 +174,8 @@ contract DepositContract is IDepositContract, ERC165 {
         ret[7] = bytesValue[0];
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor()
 // gas irOptimized: 809570
diff --git a/test/libsolidity/semanticTests/externalContracts/eof/deposit_contract.sol b/test/libsolidity/semanticTests/externalContracts/eof/deposit_contract.sol
new file mode 100644
index 000000000000..5aaaeb73a920
--- /dev/null
+++ b/test/libsolidity/semanticTests/externalContracts/eof/deposit_contract.sol
@@ -0,0 +1,216 @@
+// ┏━━━┓━┏┓━┏┓━━┏━━━┓━━┏━━━┓━━━━┏━━━┓━━━━━━━━━━━━━━━━━━━┏┓━━━━━┏━━━┓━━━━━━━━━┏┓━━━━━━━━━━━━━━┏┓━
+// ┃┏━━┛┏┛┗┓┃┃━━┃┏━┓┃━━┃┏━┓┃━━━━┗┓┏┓┃━━━━━━━━━━━━━━━━━━┏┛┗┓━━━━┃┏━┓┃━━━━━━━━┏┛┗┓━━━━━━━━━━━━┏┛┗┓
+// ┃┗━━┓┗┓┏┛┃┗━┓┗┛┏┛┃━━┃┃━┃┃━━━━━┃┃┃┃┏━━┓┏━━┓┏━━┓┏━━┓┏┓┗┓┏┛━━━━┃┃━┗┛┏━━┓┏━┓━┗┓┏┛┏━┓┏━━┓━┏━━┓┗┓┏┛
+// ┃┏━━┛━┃┃━┃┏┓┃┏━┛┏┛━━┃┃━┃┃━━━━━┃┃┃┃┃┏┓┃┃┏┓┃┃┏┓┃┃━━┫┣┫━┃┃━━━━━┃┃━┏┓┃┏┓┃┃┏┓┓━┃┃━┃┏┛┗━┓┃━┃┏━┛━┃┃━
+// ┃┗━━┓━┃┗┓┃┃┃┃┃┃┗━┓┏┓┃┗━┛┃━━━━┏┛┗┛┃┃┃━┫┃┗┛┃┃┗┛┃┣━━┃┃┃━┃┗┓━━━━┃┗━┛┃┃┗┛┃┃┃┃┃━┃┗┓┃┃━┃┗┛┗┓┃┗━┓━┃┗┓
+// ┗━━━┛━┗━┛┗┛┗┛┗━━━┛┗┛┗━━━┛━━━━┗━━━┛┗━━┛┃┏━┛┗━━┛┗━━┛┗┛━┗━┛━━━━┗━━━┛┗━━┛┗┛┗┛━┗━┛┗┛━┗━━━┛┗━━┛━┗━┛
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┗┛━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+// 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];
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// constructor()
+// gas irOptimized: 809602
+// gas irOptimized code: 558000
+// gas legacy: 919945
+// gas legacy code: 1437600
+// gas legacyOptimized: 848699
+// gas legacyOptimized code: 878200
+// 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: 109178
+// gas legacy: 142735
+// gas legacyOptimized: 117558
+// 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: 109178
+// gas legacy: 142735
+// gas legacyOptimized: 117558
+// 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: 109174
+// gas legacy: 142744
+// gas legacyOptimized: 117570
+// 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: 109174
+// gas legacy: 142744
+// gas legacyOptimized: 117570
+// get_deposit_count() -> 0x20, 8, 0x0200000000000000000000000000000000000000000000000000000000000000
diff --git a/test/libsolidity/semanticTests/externalContracts/eof/snark.sol b/test/libsolidity/semanticTests/externalContracts/eof/snark.sol
new file mode 100644
index 000000000000..f14427110788
--- /dev/null
+++ b/test/libsolidity/semanticTests/externalContracts/eof/snark.sol
@@ -0,0 +1,312 @@
+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;
+		uint return_flag;
+		assembly {
+			return_flag := extcall(6, input, 0xc0, 0)
+			// Use "invalid" to make gas estimation work
+			switch return_flag case 1 { invalid() } case 2 { invalid() }
+
+			returndatacopy(r, 0, 64)
+		}
+		require(return_flag == 0);
+	}
+
+	/// @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;
+		uint return_flag;
+		assembly {
+			return_flag := extcall(7, input, 0x80, 0)
+			// Use "invalid" to make gas estimation work
+			switch return_flag case 1 { invalid() } case 2 { invalid() }
+
+			returndatacopy(r, 0, 64)
+		}
+		require(return_flag == 0);
+	}
+
+	/// @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;
+		uint return_flag;
+		assembly {
+			return_flag := extcall(8, add(input, 0x20), mul(inputSize, 0x20), 0)
+			// Use "invalid" to make gas estimation work
+			switch return_flag case 1 { invalid() } case 2 { invalid() }
+
+			returndatacopy(out, 0, 32)
+		}
+		require(return_flag == 0);
+		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
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// library: Pairing
+// f() -> true
+// g() -> true
+// pair() -> true
+// gas irOptimized: 270424
+// gas legacy: 275206
+// gas legacyOptimized: 266925
+// verifyTx() -> true
+// ~ emit Verified(string): 0x20, 0x16, "Successfully verified."
+// gas irOptimized: 785783
+// gas legacy: 801868
+// gas legacyOptimized: 770942
diff --git a/test/libsolidity/semanticTests/externalContracts/snark.sol b/test/libsolidity/semanticTests/externalContracts/snark.sol
index 906279d17935..12407c07b85f 100644
--- a/test/libsolidity/semanticTests/externalContracts/snark.sol
+++ b/test/libsolidity/semanticTests/externalContracts/snark.sol
@@ -289,6 +289,7 @@ contract Test {
 //
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // library: Pairing
 // f() -> true
diff --git a/test/libsolidity/semanticTests/freeFunctions/free_runtimecode.sol b/test/libsolidity/semanticTests/freeFunctions/free_runtimecode.sol
index 7a05ff5d0270..e414b8205ba7 100644
--- a/test/libsolidity/semanticTests/freeFunctions/free_runtimecode.sol
+++ b/test/libsolidity/semanticTests/freeFunctions/free_runtimecode.sol
@@ -11,5 +11,7 @@ contract D {
     return test();
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> true
diff --git a/test/libsolidity/semanticTests/functionCall/call_options_overload.sol b/test/libsolidity/semanticTests/functionCall/call_options_overload.sol
index b9eb6ca42892..61e979f17536 100644
--- a/test/libsolidity/semanticTests/functionCall/call_options_overload.sol
+++ b/test/libsolidity/semanticTests/functionCall/call_options_overload.sol
@@ -10,6 +10,8 @@ contract C {
     function bal() external returns (uint) { return address(this).balance; }
     receive() external payable {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // (), 1 ether
 // call() -> 1, 2, 2, 2
diff --git a/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol b/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol
index 229618384d1e..36dfc844d934 100644
--- a/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol
+++ b/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol
@@ -21,6 +21,8 @@ contract C {
         return 7;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> FAILURE
 // g() -> FAILURE
diff --git a/test/libsolidity/semanticTests/functionCall/eof/call_options_overload.sol b/test/libsolidity/semanticTests/functionCall/eof/call_options_overload.sol
new file mode 100644
index 000000000000..fd357106532e
--- /dev/null
+++ b/test/libsolidity/semanticTests/functionCall/eof/call_options_overload.sol
@@ -0,0 +1,18 @@
+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(2, 3);
+        y = this.f{value: 10}(2, 3);
+        z = this.f{value: 10}(2, 3);
+    }
+    function bal() external returns (uint) { return address(this).balance; }
+    receive() external payable {}
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// ----
+// (), 1 ether
+// call() -> 1, 2, 2, 2
+// bal() -> 1000000000000000000
diff --git a/test/libsolidity/semanticTests/functionCall/eof/failed_create.sol b/test/libsolidity/semanticTests/functionCall/eof/failed_create.sol
new file mode 100644
index 000000000000..731c44e93fc5
--- /dev/null
+++ b/test/libsolidity/semanticTests/functionCall/eof/failed_create.sol
@@ -0,0 +1,37 @@
+contract D { constructor() payable {} }
+contract C {
+	uint public x;
+	constructor() payable {}
+	function f(uint amount) public returns (bool) {
+		x++;
+		return address((new D){value: amount, salt: bytes32(x)}()) != address(0);
+	}
+	function stack(uint depth) public payable returns (bool) {
+		if (depth > 0)
+			return this.stack(depth - 1);
+		else
+			return f(0);
+	}
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// constructor(), 20 wei
+// gas irOptimized: 61548
+// gas irOptimized code: 104600
+// gas legacy: 70147
+// gas legacy code: 215400
+// gas legacyOptimized: 61715
+// gas legacyOptimized code: 106800
+// f(uint256): 20 -> true
+// 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 -> true
+// x() -> 2
diff --git a/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol b/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol
index 6f7f020fe678..c5fa0538e6e7 100644
--- a/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol
+++ b/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol
@@ -18,6 +18,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // f(uint256): 0 -> FAILURE
 // f(uint256): 1 -> FAILURE
diff --git a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol
index 472921c1d25c..0031059c021a 100644
--- a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol
+++ b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol
@@ -20,6 +20,8 @@ contract C {
         return 1 + c;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 1 ether ->
 // gas irOptimized: 88853
diff --git a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol
index d1b6e8e866ae..a8eafb38ea1a 100644
--- a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol
+++ b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol
@@ -23,6 +23,7 @@ contract C {
 // ====
 // EVMVersion: >=byzantium
 // revertStrings: debug
+// bytecodeFormat: legacy
 // ----
 // constructor(), 1 ether ->
 // gas irOptimized: 98698
diff --git a/test/libsolidity/semanticTests/functionCall/failed_create.sol b/test/libsolidity/semanticTests/functionCall/failed_create.sol
index 657b4b5cfff6..8593eb778bff 100644
--- a/test/libsolidity/semanticTests/functionCall/failed_create.sol
+++ b/test/libsolidity/semanticTests/functionCall/failed_create.sol
@@ -15,6 +15,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // constructor(), 20 wei
 // gas irOptimized: 61548
diff --git a/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol b/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol
index e6187d06e2df..530ff71476c9 100644
--- a/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol
+++ b/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol
@@ -36,6 +36,8 @@ contract test {
         myBal = address(this).balance;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 20 wei ->
 // gas irOptimized: 120218
diff --git a/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol b/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol
index 41079af03955..3ac54c131612 100644
--- a/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol
+++ b/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol
@@ -35,6 +35,8 @@ contract test {
         myBal = address(this).balance;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 20 wei ->
 // gas irOptimized: 120218
diff --git a/test/libsolidity/semanticTests/functionTypes/address_member.sol b/test/libsolidity/semanticTests/functionTypes/address_member.sol
index a5f56f3dc688..5c635b980b39 100644
--- a/test/libsolidity/semanticTests/functionTypes/address_member.sol
+++ b/test/libsolidity/semanticTests/functionTypes/address_member.sol
@@ -6,5 +6,7 @@ contract C {
         a2 = [this.f.address][0];
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e, 0xc06afe3a8444fc0004668591e8306bfb9968e79e
diff --git a/test/libsolidity/semanticTests/functionTypes/eof/address_member.sol b/test/libsolidity/semanticTests/functionTypes/eof/address_member.sol
new file mode 100644
index 000000000000..e99ee153147c
--- /dev/null
+++ b/test/libsolidity/semanticTests/functionTypes/eof/address_member.sol
@@ -0,0 +1,20 @@
+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];
+    }
+
+    function checkAddress() public returns (bool) {
+        address a1;
+        address a2;
+        (a1, a2) = f();
+        return (a1 != address(0) && a1 == a2);
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// checkAddress() -> true
diff --git a/test/libsolidity/semanticTests/functionTypes/eof/function_external_delete_storage.sol b/test/libsolidity/semanticTests/functionTypes/eof/function_external_delete_storage.sol
new file mode 100644
index 000000000000..8f183d255abc
--- /dev/null
+++ b/test/libsolidity/semanticTests/functionTypes/eof/function_external_delete_storage.sol
@@ -0,0 +1,39 @@
+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;
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// x() -> 0
+// y() -> 0
+// increment() ->
+// y() -> 1
+// set() ->
+// increment() ->
+// y() -> 2
+// incrementIndirectly() ->
+// y() -> 3
+// deleteFunction() ->
+// increment() ->
+// y() -> 4
+// incrementIndirectly() ->
+// y() -> 4
diff --git a/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol b/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol
index d5e105e5f536..eea75b29d14e 100644
--- a/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol
+++ b/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol
@@ -19,6 +19,8 @@ contract C {
         delete x;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // x() -> 0
 // y() -> 0
diff --git a/test/libsolidity/semanticTests/functionTypes/stack_height_check_on_adding_gas_variable_to_function.sol b/test/libsolidity/semanticTests/functionTypes/stack_height_check_on_adding_gas_variable_to_function.sol
index f811988fec9a..1ca391e81095 100644
--- a/test/libsolidity/semanticTests/functionTypes/stack_height_check_on_adding_gas_variable_to_function.sol
+++ b/test/libsolidity/semanticTests/functionTypes/stack_height_check_on_adding_gas_variable_to_function.sol
@@ -19,5 +19,7 @@ contract C {
         return true;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test_function() -> true
diff --git a/test/libsolidity/semanticTests/immutable/eof/multi_creation.sol b/test/libsolidity/semanticTests/immutable/eof/multi_creation.sol
new file mode 100644
index 000000000000..a1e186fe5733
--- /dev/null
+++ b/test/libsolidity/semanticTests/immutable/eof/multi_creation.sol
@@ -0,0 +1,40 @@
+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{salt: hex"00"}()).f();
+		y = (new B{salt: hex"00"}()).f();
+	}
+	function f() public returns (uint256, uint, uint) {
+		return (a, (new A{salt: hex"01"}()).f(), (new B{salt: hex"01"}()).f());
+	}
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f() -> 3, 7, 5
+// gas irOptimized: 86796
+// gas irOptimized code: 37200
+// gas legacy: 87728
+// gas legacy code: 60800
+// gas legacyOptimized: 86771
+// gas legacyOptimized code: 37200
+// x() -> 7
+// y() -> 5
diff --git a/test/libsolidity/semanticTests/immutable/multi_creation.sol b/test/libsolidity/semanticTests/immutable/multi_creation.sol
index aa8a1ad8a860..fa56492d594a 100644
--- a/test/libsolidity/semanticTests/immutable/multi_creation.sol
+++ b/test/libsolidity/semanticTests/immutable/multi_creation.sol
@@ -25,6 +25,8 @@ contract C {
 		return (a, (new A()).f(), (new B()).f());
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 3, 7, 5
 // gas irOptimized: 86796
diff --git a/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol b/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol
index 0865ed2876ad..1a76665d4283 100644
--- a/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol
+++ b/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol
@@ -18,6 +18,8 @@ contract D {
         return (new C()).transfer(5);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 1
 // gas irOptimized: 77051
diff --git a/test/libsolidity/semanticTests/inheritance/eof/address_overload_resolution.sol b/test/libsolidity/semanticTests/inheritance/eof/address_overload_resolution.sol
new file mode 100644
index 000000000000..2825bc2dcb98
--- /dev/null
+++ b/test/libsolidity/semanticTests/inheritance/eof/address_overload_resolution.sol
@@ -0,0 +1,32 @@
+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{salt: hex"00"}()).balance();
+    }
+
+    function g() public returns (uint256) {
+        return (new C{salt: hex"01"}()).transfer(5);
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f() -> 1
+// gas irOptimized: 77051
+// gas legacy: 54480
+// gas legacy code: 57800
+// g() -> 5
+// gas irOptimized: 77106
+// gas legacy: 55016
+// gas legacy code: 57800
diff --git a/test/libsolidity/semanticTests/inheritance/eof/member_notation_ctor.sol b/test/libsolidity/semanticTests/inheritance/eof/member_notation_ctor.sol
new file mode 100644
index 000000000000..98498a209d72
--- /dev/null
+++ b/test/libsolidity/semanticTests/inheritance/eof/member_notation_ctor.sol
@@ -0,0 +1,29 @@
+==== 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{salt: bytes32(uint256(p))}(p);
+		return d.getX();
+	}
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// g(int256): -1 -> -1
+// gas legacy: 77878
+// gas legacy code: 24200
+// g(int256): 10 -> 10
+// gas legacy: 77506
+// gas legacy code: 24200
diff --git a/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol b/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol
index b9697c5ae1d7..494b4adb265e 100644
--- a/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol
+++ b/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol
@@ -17,6 +17,8 @@ contract A {
 		return d.getX();
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // g(int256): -1 -> -1
 // gas legacy: 77876
diff --git a/test/libsolidity/semanticTests/inlineAssembly/eof/external_function_pointer_address.sol b/test/libsolidity/semanticTests/inlineAssembly/eof/external_function_pointer_address.sol
new file mode 100644
index 000000000000..93e998beeec4
--- /dev/null
+++ b/test/libsolidity/semanticTests/inlineAssembly/eof/external_function_pointer_address.sol
@@ -0,0 +1,25 @@
+contract C {
+	function testFunction() external {}
+	address contractAddress = address(this);
+	function testYul() public returns (bool) {
+		require(contractAddress != address(0));
+		function() external fp = this.testFunction;
+
+		address adr;
+		assembly {
+			adr := fp.address
+		}
+
+		return adr == contractAddress;
+	}
+	function testSol() public returns (bool) {
+		require(contractAddress != address(0));
+		return this.testFunction.address == contractAddress;
+	}
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// testYul() -> true
+// testSol() -> true
diff --git a/test/libsolidity/semanticTests/inlineAssembly/eof/transient_storage_low_level_calls.sol b/test/libsolidity/semanticTests/inlineAssembly/eof/transient_storage_low_level_calls.sol
new file mode 100644
index 000000000000..a7a7f118e777
--- /dev/null
+++ b/test/libsolidity/semanticTests/inlineAssembly/eof/transient_storage_low_level_calls.sol
@@ -0,0 +1,78 @@
+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{salt: hex"00"}();
+        // 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{salt: hex"01"}();
+        // 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{salt: hex"02"}();
+        (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{salt: hex"03"}();
+        (bool success, ) = address(d).staticcall(abi.encodeCall(d.addOne, ()));
+        require(!success);
+        return true;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// testDelegateCall() -> true
+// testCall() -> true
+// tloadAllowedStaticCall() -> true
+// tstoreNotAllowedStaticCall() -> true
+// gas irOptimized: 98419720
+// gas irOptimized code: 19000
+// gas legacy: 98409086
+// gas legacy code: 30000
+// gas legacyOptimized: 98420962
+// gas legacyOptimized code: 17800
diff --git a/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol b/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol
index ae891df5dc4f..79fa07d21d48 100644
--- a/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol
+++ b/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol
@@ -12,6 +12,8 @@ contract C {
 		return this.testFunction.address;
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // testYul() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
 // testSol() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
diff --git a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol
index e43fc475740a..b8227f7996b1 100644
--- a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol
+++ b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol
@@ -63,6 +63,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // testDelegateCall() -> true
 // testCall() -> true
diff --git a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol
index c2066ef8be1e..26bb09edca7a 100644
--- a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol
+++ b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol
@@ -38,6 +38,7 @@ contract D {
 }
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // constructor() ->
 // gas irOptimized: 127596
diff --git a/test/libsolidity/semanticTests/interface_inheritance_conversions.sol b/test/libsolidity/semanticTests/interface_inheritance_conversions.sol
index 62e1e4fba6dc..ddfd14081c16 100644
--- a/test/libsolidity/semanticTests/interface_inheritance_conversions.sol
+++ b/test/libsolidity/semanticTests/interface_inheritance_conversions.sol
@@ -32,6 +32,8 @@ contract C {
         return (sb.parentFun(), sb.subBFun());
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // convertParent() -> 1
 // gas irOptimized: 85524
diff --git a/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol b/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol
index 1240a8251427..0295a342dd2b 100644
--- a/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol
+++ b/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol
@@ -14,6 +14,8 @@ contract ClientReceipt {
         return other.getAddress();
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 2000 wei ->
 // gas irOptimized: 114353
diff --git a/test/libsolidity/semanticTests/isoltestTesting/eof/balance_other_contract.sol b/test/libsolidity/semanticTests/isoltestTesting/eof/balance_other_contract.sol
new file mode 100644
index 000000000000..6b848702e3a9
--- /dev/null
+++ b/test/libsolidity/semanticTests/isoltestTesting/eof/balance_other_contract.sol
@@ -0,0 +1,35 @@
+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();
+    }
+    function checkBalance() public returns (bool) {
+        return getAddress().balance == 500;
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// constructor(), 2000 wei ->
+// gas irOptimized: 114353
+// gas irOptimized code: 58800
+// gas legacy: 118618
+// gas legacy code: 111400
+// gas legacyOptimized: 114067
+// gas legacyOptimized code: 59800
+// balance -> 1500
+// gas irOptimized: 191881
+// gas legacy: 235167
+// gas legacyOptimized: 180756
+// checkBalance() -> true
diff --git a/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_pure_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_pure_external_call.sol
new file mode 100644
index 000000000000..2f4361d862cb
--- /dev/null
+++ b/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_pure_external_call.sol
@@ -0,0 +1,68 @@
+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{salt: hex"00"}());
+
+        return x + y;
+    }
+
+    function testInc(Int32 x) public returns (Int32) {
+        storeAdder(new Adder{salt: hex"01"}());
+
+        return -x;
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// testMul(int32,int32): 42, 10 -> 420
+// gas irOptimized: 102563
+// gas legacy: 56981
+// gas legacy code: 127000
+// gas legacyOptimized: 55163
+// gas legacyOptimized code: 68400
+// testInc(int32): 42 -> 43
+// gas irOptimized: 102386
+// gas legacy: 56239
+// gas legacy code: 127000
+// gas legacyOptimized: 54851
+// gas legacyOptimized code: 68400
diff --git a/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_view_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_view_external_call.sol
new file mode 100644
index 000000000000..7be2f6a6f20a
--- /dev/null
+++ b/test/libsolidity/semanticTests/operators/userDefined/eof/operator_making_view_external_call.sol
@@ -0,0 +1,74 @@
+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{salt: hex"00"}());
+
+        return x + y;
+    }
+
+    function testInc(Int32 x) public returns (Int32) {
+        storeAdder(new Adder{salt: hex"01"}());
+
+        return -x;
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// testMul(int32,int32): 42, 10 -> 420
+// gas irOptimized: 102563
+// gas legacy: 56981
+// gas legacy code: 127000
+// gas legacyOptimized: 55163
+// gas legacyOptimized code: 68400
+// testInc(int32): 42 -> 43
+// gas irOptimized: 102386
+// gas legacy: 56239
+// gas legacy code: 127000
+// gas legacyOptimized: 54851
+// gas legacyOptimized code: 68400
diff --git a/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol
index ec41099eecbb..6727350a9f5d 100644
--- a/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol
+++ b/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol
@@ -50,6 +50,8 @@ contract C {
         return -x;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // testMul(int32,int32): 42, 10 -> 420
 // gas irOptimized: 102563
diff --git a/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol
index 7e70eb091bf6..0f94987eabf1 100644
--- a/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol
+++ b/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol
@@ -56,6 +56,8 @@ contract C {
         return -x;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // testMul(int32,int32): 42, 10 -> 420
 // gas irOptimized: 102563
diff --git a/test/libsolidity/semanticTests/revertStrings/called_contract_has_code.sol b/test/libsolidity/semanticTests/revertStrings/called_contract_has_code.sol
index 110b1e50c724..d9a6549252f1 100644
--- a/test/libsolidity/semanticTests/revertStrings/called_contract_has_code.sol
+++ b/test/libsolidity/semanticTests/revertStrings/called_contract_has_code.sol
@@ -8,5 +8,6 @@ contract C {
 // ====
 // EVMVersion: >=byzantium
 // revertStrings: debug
+// bytecodeFormat: legacy
 // ----
 // g() -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
diff --git a/test/libsolidity/semanticTests/reverts/eof/revert_return_area.sol b/test/libsolidity/semanticTests/reverts/eof/revert_return_area.sol
new file mode 100644
index 000000000000..8937f619e771
--- /dev/null
+++ b/test/libsolidity/semanticTests/reverts/eof/revert_return_area.sol
@@ -0,0 +1,21 @@
+contract C {
+    fallback() external {
+        revert("abc");
+    }
+
+    function f() public returns (uint s, uint r) {
+        address x = address(this);
+        assembly {
+            mstore(0, 7)
+            s := extcall(x, 0, 0, 0)
+            returndatacopy(0, 0, 32)
+            r := mload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f() -> 0x01, 0x08c379a000000000000000000000000000000000000000000000000000000000
diff --git a/test/libsolidity/semanticTests/reverts/revert_return_area.sol b/test/libsolidity/semanticTests/reverts/revert_return_area.sol
index 8ab4ca22722c..5f276f91c948 100644
--- a/test/libsolidity/semanticTests/reverts/revert_return_area.sol
+++ b/test/libsolidity/semanticTests/reverts/revert_return_area.sol
@@ -14,5 +14,6 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // f() -> 0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000
diff --git a/test/libsolidity/semanticTests/salted_create/eof/salted_create_with_value.sol b/test/libsolidity/semanticTests/salted_create/eof/salted_create_with_value.sol
new file mode 100644
index 000000000000..830ed99d3b25
--- /dev/null
+++ b/test/libsolidity/semanticTests/salted_create/eof/salted_create_with_value.sol
@@ -0,0 +1,31 @@
+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: "abc0", value: 3}(7);
+        B y = new B{value: 3, salt: "abc1"}(8);
+        B z = new B{salt: "abc2", value: 3}(9);
+        return (x.getBalance(), y.getBalance(), z.getBalance());
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f(), 10 ether -> 3007, 3008, 3009
+// gas irOptimized: 187022
+// gas irOptimized code: 67200
+// gas legacy: 190863
+// gas legacy code: 190200
+// gas legacyOptimized: 187258
+// gas legacyOptimized code: 92400
diff --git a/test/libsolidity/semanticTests/salted_create/prediction_example.sol b/test/libsolidity/semanticTests/salted_create/prediction_example.sol
index 7d0e3c8b0dbc..f1f62db03230 100644
--- a/test/libsolidity/semanticTests/salted_create/prediction_example.sol
+++ b/test/libsolidity/semanticTests/salted_create/prediction_example.sol
@@ -24,6 +24,7 @@ contract C {
 // ====
 // EVMVersion: >=constantinople
 // compileViaYul: also
+// bytecodeFormat: legacy
 // ----
 // createDSalted(bytes32,uint256): 42, 64 ->
 // gas legacy: 78573
diff --git a/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol b/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol
index 25d1935770d1..c810000e5b3c 100644
--- a/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol
+++ b/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol
@@ -19,6 +19,7 @@ contract A {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // f(), 10 ether -> 3007, 3008, 3009
 // gas irOptimized: 187022
diff --git a/test/libsolidity/semanticTests/shanghai/evmone_support.sol b/test/libsolidity/semanticTests/shanghai/evmone_support.sol
index 359dc516ffcd..4f3c0ee1ba6a 100644
--- a/test/libsolidity/semanticTests/shanghai/evmone_support.sol
+++ b/test/libsolidity/semanticTests/shanghai/evmone_support.sol
@@ -26,6 +26,7 @@ contract Test {
 // ====
 // compileViaYul: also
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // bytecode() -> 0x20, 4, 0x60205ff300000000000000000000000000000000000000000000000000000000
 // isPush0Supported() -> true
diff --git a/test/libsolidity/semanticTests/state/gasleft.sol b/test/libsolidity/semanticTests/state/gasleft.sol
index 6ce623ce81ea..2d4a37b48d8b 100644
--- a/test/libsolidity/semanticTests/state/gasleft.sol
+++ b/test/libsolidity/semanticTests/state/gasleft.sol
@@ -3,6 +3,8 @@ contract C {
         return gasleft() > 0;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> true
 // f() -> true
diff --git a/test/libsolidity/semanticTests/tryCatch/assert.sol b/test/libsolidity/semanticTests/tryCatch/assert.sol
index 8b6a7b99692e..e3b0a3853d59 100644
--- a/test/libsolidity/semanticTests/tryCatch/assert.sol
+++ b/test/libsolidity/semanticTests/tryCatch/assert.sol
@@ -11,6 +11,8 @@ contract C {
         }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f(bool): true -> 1
 // f(bool): false -> 2
diff --git a/test/libsolidity/semanticTests/tryCatch/create.sol b/test/libsolidity/semanticTests/tryCatch/create.sol
index 43d0f22f6506..23d1951b0dbd 100644
--- a/test/libsolidity/semanticTests/tryCatch/create.sol
+++ b/test/libsolidity/semanticTests/tryCatch/create.sol
@@ -27,6 +27,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // f() -> 0, 0, 96, 13, "test message."
 // g() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a, 0, 96, 7, "success"
diff --git a/test/libsolidity/semanticTests/tryCatch/eof/assert.sol b/test/libsolidity/semanticTests/tryCatch/eof/assert.sol
new file mode 100644
index 000000000000..d1030ea0fb2a
--- /dev/null
+++ b/test/libsolidity/semanticTests/tryCatch/eof/assert.sol
@@ -0,0 +1,17 @@
+contract C {
+    function g(bool x) public pure {
+        assert(x);
+    }
+    function f(bool x) public returns (uint) {
+        try this.g(x) {
+            return 1;
+        } catch {
+            return 2;
+        }
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// ----
+// f(bool): true -> 1
+// f(bool): false -> 2
diff --git a/test/libsolidity/semanticTests/tryCatch/eof/create.sol b/test/libsolidity/semanticTests/tryCatch/eof/create.sol
new file mode 100644
index 000000000000..160ec69f6e5b
--- /dev/null
+++ b/test/libsolidity/semanticTests/tryCatch/eof/create.sol
@@ -0,0 +1,33 @@
+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 (bool x, uint, string memory txt) {
+        uint i = 8;
+        try new Succeeds(i) returns (Succeeds r) {
+            x = address(r) != address(0);
+            txt = "success";
+        } catch Error(string memory s) {
+            txt = s;
+        }
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f() -> 0, 0, 96, 13, "test message."
+// g() -> true, 0, 0x60, 7, "success"
diff --git a/test/libsolidity/semanticTests/tryCatch/eof/return_function.sol b/test/libsolidity/semanticTests/tryCatch/eof/return_function.sol
new file mode 100644
index 000000000000..e4a18e25c45c
--- /dev/null
+++ b/test/libsolidity/semanticTests/tryCatch/eof/return_function.sol
@@ -0,0 +1,20 @@
+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, bool, uint) {
+        // Note that the function type uses two stack slots.
+        try this.g() returns (uint a, function() external h, uint b) {
+            return (a, h == this.fun, b);
+        } catch {
+        }
+    }
+    function fun() public pure {}
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f() -> 1, true, 9
diff --git a/test/libsolidity/semanticTests/tryCatch/eof/trivial.sol b/test/libsolidity/semanticTests/tryCatch/eof/trivial.sol
new file mode 100644
index 000000000000..cbbccb4d75e7
--- /dev/null
+++ b/test/libsolidity/semanticTests/tryCatch/eof/trivial.sol
@@ -0,0 +1,17 @@
+contract C {
+    function g(bool x) public pure {
+        require(x);
+    }
+    function f(bool x) public returns (uint) {
+        try this.g(x) {
+            return 1;
+        } catch {
+            return 2;
+        }
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// ----
+// f(bool): true -> 1
+// f(bool): false -> 2
diff --git a/test/libsolidity/semanticTests/tryCatch/return_function.sol b/test/libsolidity/semanticTests/tryCatch/return_function.sol
index 6aac30fe4617..37efc76c590f 100644
--- a/test/libsolidity/semanticTests/tryCatch/return_function.sol
+++ b/test/libsolidity/semanticTests/tryCatch/return_function.sol
@@ -13,5 +13,7 @@ contract C {
     }
     function fun() public pure {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0x1, 0xc06afe3a8444fc0004668591e8306bfb9968e79e946644cd0000000000000000, 9
diff --git a/test/libsolidity/semanticTests/tryCatch/trivial.sol b/test/libsolidity/semanticTests/tryCatch/trivial.sol
index d43477e994ab..7683743c576d 100644
--- a/test/libsolidity/semanticTests/tryCatch/trivial.sol
+++ b/test/libsolidity/semanticTests/tryCatch/trivial.sol
@@ -11,6 +11,8 @@ contract C {
         }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f(bool): true -> 1
 // f(bool): false -> 2
diff --git a/test/libsolidity/semanticTests/various/address_code.sol b/test/libsolidity/semanticTests/various/address_code.sol
index 549512eb3e44..4d810f970987 100644
--- a/test/libsolidity/semanticTests/various/address_code.sol
+++ b/test/libsolidity/semanticTests/various/address_code.sol
@@ -12,6 +12,8 @@ contract C {
     function g() public view returns (uint) { return address(0).code.length; }
     function h() public view returns (uint) { return address(1).code.length; }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor() ->
 // gas irOptimized: 70760
diff --git a/test/libsolidity/semanticTests/various/address_code_complex.sol b/test/libsolidity/semanticTests/various/address_code_complex.sol
index f2d21c9069b3..d228d99d1767 100644
--- a/test/libsolidity/semanticTests/various/address_code_complex.sol
+++ b/test/libsolidity/semanticTests/various/address_code_complex.sol
@@ -12,6 +12,8 @@ contract C {
     function f() public returns (bytes memory) { return address(new A()).code; }
     function g() public returns (uint) { return address(new A()).code.length; }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0x20, 0x20, 0x48aa5566000000
 // g() -> 0x20
diff --git a/test/libsolidity/semanticTests/various/code_access_content.sol b/test/libsolidity/semanticTests/various/code_access_content.sol
index 22ceff337f89..b8b13b3c677f 100644
--- a/test/libsolidity/semanticTests/various/code_access_content.sol
+++ b/test/libsolidity/semanticTests/various/code_access_content.sol
@@ -36,6 +36,8 @@ contract C {
         return true;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // testRuntime() -> true
 // gas legacy: 76575
diff --git a/test/libsolidity/semanticTests/various/code_access_create.sol b/test/libsolidity/semanticTests/various/code_access_create.sol
index f5f0b8644423..1f958cc9d106 100644
--- a/test/libsolidity/semanticTests/various/code_access_create.sol
+++ b/test/libsolidity/semanticTests/various/code_access_create.sol
@@ -21,6 +21,8 @@ contract C {
         return d.f();
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> 7
 // gas legacy: 76647
diff --git a/test/libsolidity/semanticTests/various/code_access_padding.sol b/test/libsolidity/semanticTests/various/code_access_padding.sol
index 831d4bde4ab4..6c07fb4e089e 100644
--- a/test/libsolidity/semanticTests/various/code_access_padding.sol
+++ b/test/libsolidity/semanticTests/various/code_access_padding.sol
@@ -14,5 +14,7 @@ contract C {
         }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // diff() -> 0 # This checks that the allocation function pads to multiples of 32 bytes #
diff --git a/test/libsolidity/semanticTests/various/code_access_runtime.sol b/test/libsolidity/semanticTests/various/code_access_runtime.sol
index 10d7c1852e95..0c848fc592eb 100644
--- a/test/libsolidity/semanticTests/various/code_access_runtime.sol
+++ b/test/libsolidity/semanticTests/various/code_access_runtime.sol
@@ -21,6 +21,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // test() -> 42
 // gas legacy: 76034
diff --git a/test/libsolidity/semanticTests/various/code_length.sol b/test/libsolidity/semanticTests/various/code_length.sol
index 844a0f65706f..08065b302c99 100644
--- a/test/libsolidity/semanticTests/various/code_length.sol
+++ b/test/libsolidity/semanticTests/various/code_length.sol
@@ -57,6 +57,8 @@ contract C {
 
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor()
 // gas legacy: 66989
diff --git a/test/libsolidity/semanticTests/various/code_length_contract_member.sol b/test/libsolidity/semanticTests/various/code_length_contract_member.sol
index ff883139a46e..79e940080f02 100644
--- a/test/libsolidity/semanticTests/various/code_length_contract_member.sol
+++ b/test/libsolidity/semanticTests/various/code_length_contract_member.sol
@@ -11,5 +11,7 @@ contract C {
         return (s.code.length, s.another.length, address(this).code.length > 50);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0x20, 0x20, true
diff --git a/test/libsolidity/semanticTests/various/codehash.sol b/test/libsolidity/semanticTests/various/codehash.sol
index fa7dab9dab9f..465e2ee31b51 100644
--- a/test/libsolidity/semanticTests/various/codehash.sol
+++ b/test/libsolidity/semanticTests/various/codehash.sol
@@ -13,6 +13,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // f() -> 0x0
 // g() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
diff --git a/test/libsolidity/semanticTests/various/codehash_assembly.sol b/test/libsolidity/semanticTests/various/codehash_assembly.sol
index fe2210fa107a..81c2286d5e44 100644
--- a/test/libsolidity/semanticTests/various/codehash_assembly.sol
+++ b/test/libsolidity/semanticTests/various/codehash_assembly.sol
@@ -17,6 +17,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // f() -> 0
 // g() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
diff --git a/test/libsolidity/semanticTests/various/create_calldata.sol b/test/libsolidity/semanticTests/various/create_calldata.sol
index a5f61d2ddd67..7e3e326228a7 100644
--- a/test/libsolidity/semanticTests/various/create_calldata.sol
+++ b/test/libsolidity/semanticTests/various/create_calldata.sol
@@ -6,6 +6,8 @@ contract C {
 		assert(msg.data.length == 0);
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(): 42 ->
 // gas irOptimized: 68239
diff --git a/test/libsolidity/semanticTests/various/create_random.sol b/test/libsolidity/semanticTests/various/create_random.sol
index 676ec32a89ae..b053deb442ed 100644
--- a/test/libsolidity/semanticTests/various/create_random.sol
+++ b/test/libsolidity/semanticTests/various/create_random.sol
@@ -33,6 +33,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // addr() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
 // testRunner() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a, 0x2c1c30623ddd93e0b765a6caaca0c859eeb0644d
diff --git a/test/libsolidity/semanticTests/various/eof/many_subassemblies.sol b/test/libsolidity/semanticTests/various/eof/many_subassemblies.sol
new file mode 100644
index 000000000000..98ba4a92157a
--- /dev/null
+++ b/test/libsolidity/semanticTests/various/eof/many_subassemblies.sol
@@ -0,0 +1,41 @@
+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{salt: hex"00"}();
+        new C1{salt: hex"01"}();
+        new C2{salt: hex"02"}();
+        new C3{salt: hex"03"}();
+        new C4{salt: hex"04"}();
+        new C5{salt: hex"05"}();
+        new C6{salt: hex"06"}();
+        new C7{salt: hex"07"}();
+        new C8{salt: hex"08"}();
+        new C9{salt: hex"09"}();
+        new C10{salt: hex"0a"}();
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// run() ->
+// gas irOptimized: 374934
+// gas irOptimized code: 6600
+// gas legacy: 375119
+// gas legacy code: 17600
+// gas legacyOptimized: 375119
+// gas legacyOptimized code: 17600
diff --git a/test/libsolidity/semanticTests/various/eof/value_complex.sol b/test/libsolidity/semanticTests/various/eof/value_complex.sol
new file mode 100644
index 000000000000..ccf10106ada9
--- /dev/null
+++ b/test/libsolidity/semanticTests/various/eof/value_complex.sol
@@ -0,0 +1,30 @@
+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}();
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 114463
+// gas irOptimized code: 58800
+// gas legacy: 120091
+// gas legacy code: 132400
+// gas legacyOptimized: 114536
+// gas legacyOptimized code: 65800
+// sendAmount(uint256): 5 -> 8
diff --git a/test/libsolidity/semanticTests/various/eof/value_insane.sol b/test/libsolidity/semanticTests/various/eof/value_insane.sol
new file mode 100644
index 000000000000..2b65d11eed9f
--- /dev/null
+++ b/test/libsolidity/semanticTests/various/eof/value_insane.sol
@@ -0,0 +1,29 @@
+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}();
+    }
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 114527
+// gas irOptimized code: 59600
+// gas legacy: 120199
+// gas legacy code: 133600
+// gas legacyOptimized: 114568
+// gas legacyOptimized code: 66200
+// sendAmount(uint256): 5 -> 8
diff --git a/test/libsolidity/semanticTests/various/gasleft_decrease.sol b/test/libsolidity/semanticTests/various/gasleft_decrease.sol
index ab7302743f64..ea891edc4e5f 100644
--- a/test/libsolidity/semanticTests/various/gasleft_decrease.sol
+++ b/test/libsolidity/semanticTests/various/gasleft_decrease.sol
@@ -14,6 +14,8 @@ contract C {
         return true;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> true
 // g() -> true
diff --git a/test/libsolidity/semanticTests/various/many_subassemblies.sol b/test/libsolidity/semanticTests/various/many_subassemblies.sol
index b270c7006694..00c71a8ff0bf 100644
--- a/test/libsolidity/semanticTests/various/many_subassemblies.sol
+++ b/test/libsolidity/semanticTests/various/many_subassemblies.sol
@@ -28,6 +28,8 @@ contract D {
         new C10();
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // run() ->
 // gas irOptimized: 374934
diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol
index 4cb5c8c713bf..bf70caee5b54 100644
--- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol
+++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol
@@ -62,6 +62,7 @@ contract D {
 }
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // constructor(), 1 ether ->
 // gas irOptimized: 67028
diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol
index a582649196c3..7629fabc1ce2 100644
--- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol
+++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol
@@ -33,6 +33,7 @@ contract D {
 }
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // constructor(), 2 ether ->
 // gas irOptimized: 108104
diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol
index dd550d31a0cf..c9f50046c07d 100644
--- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol
+++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol
@@ -80,6 +80,7 @@ contract D {
 
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // constructor(), 1 ether ->
 // gas irOptimized: 132974
diff --git a/test/libsolidity/semanticTests/various/value_complex.sol b/test/libsolidity/semanticTests/various/value_complex.sol
index 4639d34c7071..8fc4a7293ff6 100644
--- a/test/libsolidity/semanticTests/various/value_complex.sol
+++ b/test/libsolidity/semanticTests/various/value_complex.sol
@@ -17,6 +17,8 @@ contract test {
         return h.getBalance{value: amount + 3, gas: 1000}();
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 20 wei ->
 // gas irOptimized: 114463
diff --git a/test/libsolidity/semanticTests/various/value_insane.sol b/test/libsolidity/semanticTests/various/value_insane.sol
index bc6a803de92f..4bd6746e5fa3 100644
--- a/test/libsolidity/semanticTests/various/value_insane.sol
+++ b/test/libsolidity/semanticTests/various/value_insane.sol
@@ -16,6 +16,8 @@ contract test {
         return h.getBalance{value: amount + 3, gas: 1000}();
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor(), 20 wei ->
 // gas irOptimized: 114527
diff --git a/test/libsolidity/semanticTests/viaYul/conversion/eof/function_cast.sol b/test/libsolidity/semanticTests/viaYul/conversion/eof/function_cast.sol
new file mode 100644
index 000000000000..952b34c28f53
--- /dev/null
+++ b/test/libsolidity/semanticTests/viaYul/conversion/eof/function_cast.sol
@@ -0,0 +1,24 @@
+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(function(uint) external returns (uint) x, function(uint) external view returns (uint) y) external view returns (
+			function(uint) external returns (uint) a,
+			function(uint) external view returns (uint) b) {
+		a = x;
+		b = y;
+	}
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f(uint256): 2 -> 4
+// h(uint256): 2 -> 5
+// t(function, function): left(0x51ac6a341cdab4263623cddef6e4860d0679b0a9b3de648b0000000000000000), left(0x51ac6a341cdab4263623cddef6e4860d0679b0a9b3de648b0000000000000000) -> 0x51ac6a341cdab4263623cddef6e4860d0679b0a9b3de648b0000000000000000, 0x51ac6a341cdab4263623cddef6e4860d0679b0a9b3de648b0000000000000000
diff --git a/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol b/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol
index 843376baa553..ef975bb4354d 100644
--- a/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol
+++ b/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol
@@ -15,6 +15,8 @@ contract C {
 		b = this.f;
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f(uint256): 2 -> 4
 // h(uint256): 2 -> 5
diff --git a/test/libsolidity/semanticTests/viaYul/eof/function_address.sol b/test/libsolidity/semanticTests/viaYul/eof/function_address.sol
new file mode 100644
index 000000000000..5ac91bff988b
--- /dev/null
+++ b/test/libsolidity/semanticTests/viaYul/eof/function_address.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() external returns (bool) {
+        return this.f.address != address(0);
+    }
+    function g() external returns (bool) {
+      return this.f.address == address(this);
+    }
+    function h(function() external a) public returns (address) {
+      return a.address;
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f() -> true
+// g() -> true
+// h(function): left(0x1122334400112233445566778899AABBCCDDEEFF42424242) -> 0x1122334400112233445566778899AABBCCDDEEFF
diff --git a/test/libsolidity/semanticTests/viaYul/function_address.sol b/test/libsolidity/semanticTests/viaYul/function_address.sol
index 0c1c58dd821d..c2be3cd0498a 100644
--- a/test/libsolidity/semanticTests/viaYul/function_address.sol
+++ b/test/libsolidity/semanticTests/viaYul/function_address.sol
@@ -9,6 +9,8 @@ contract C {
       return a.address;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
 // g() -> true
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_accessing_public_state_variable_via_v1_type.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_accessing_public_state_variable_via_v1_type.sol
index f324d2c33e30..036a2597616c 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_accessing_public_state_variable_via_v1_type.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_accessing_public_state_variable_via_v1_type.sol
@@ -13,4 +13,6 @@ contract D {
         return a + b;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol
index b21b7cfaff5e..03fb9bae673b 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v1_library_function_accepting_storage_struct.sol
@@ -19,4 +19,6 @@ contract Test {
         L.set(item);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol
index 41bc072a5949..01d9658ce2cf 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_function_accepting_storage_struct.sol
@@ -19,4 +19,6 @@ contract Test {
         L.get(item);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol
index 78d7b0512414..ef066593c4bc 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_modifier.sol
@@ -25,4 +25,6 @@ contract C is B {
         validate()
     {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol
index 1ac5d713b104..b937d1e2d1a2 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_constructor_with_v2_modifier.sol
@@ -32,4 +32,6 @@ import "B";
 contract D is C {
     constructor() validate B() validate C() validate {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol
index 073a125be984..9743d5318ca0 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_calling_v2_function.sol
@@ -23,4 +23,6 @@ pragma abicoder v1;
 import "A";
 
 contract C is B {}
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol
index 963ed33c70e6..e4492a4ef742 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_defining_v2_event.sol
@@ -13,4 +13,6 @@ pragma abicoder v1;
 import "A";
 
 contract D is C {}
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol
index 8aa2f8552c2b..5ae4cb0ed836 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_inheritance_from_contract_emitting_v2_event.sol
@@ -19,4 +19,6 @@ pragma abicoder v1;
 import "A";
 
 contract D is C {}
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol
index dd102cf51378..9a809b50a2fe 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_modifier_overriding_v2_modifier.sol
@@ -27,4 +27,6 @@ contract C is B {
         _;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol b/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol
index e5df9cc82237..6665c42efd49 100644
--- a/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol
+++ b/test/libsolidity/syntaxTests/abiEncoder/v1_v2_v1_modifier_mix.sol
@@ -52,4 +52,6 @@ struct Data {
 contract X {
     function get() public view returns (Data memory) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol b/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol
index 9aa5fce1211a..581aa8482203 100644
--- a/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol
+++ b/test/libsolidity/syntaxTests/array/nested_calldata_storage.sol
@@ -5,5 +5,7 @@ contract C {
   function i(uint[][2] calldata s) external { tmp_i = s; }
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (35-127): Copying nested calldata dynamic arrays to storage is not implemented in the old code generator.
diff --git a/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol b/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol
index f1125b4d232b..98c2ccac0f1c 100644
--- a/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol
+++ b/test/libsolidity/syntaxTests/array/nested_calldata_storage2.sol
@@ -5,5 +5,7 @@ contract C {
   function i(uint[][] calldata s) external { tmp_i = s; }
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (35-125): Copying nested calldata dynamic arrays to storage is not implemented in the old code generator.
diff --git a/test/libsolidity/syntaxTests/bytecodeReferences/library_non_called.sol b/test/libsolidity/syntaxTests/bytecodeReferences/library_non_called.sol
index b7392ff3ee74..1374c3110d35 100644
--- a/test/libsolidity/syntaxTests/bytecodeReferences/library_non_called.sol
+++ b/test/libsolidity/syntaxTests/bytecodeReferences/library_non_called.sol
@@ -7,5 +7,7 @@ library L2 {
 contract A {
     function f() public pure { type(L2).creationCode; }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 6133: (157-178): Statement has no effect.
diff --git a/test/libsolidity/syntaxTests/constants/mod_div_rational.sol b/test/libsolidity/syntaxTests/constants/mod_div_rational.sol
index 68d3bfc7ae03..6ea4dd8f8e8d 100644
--- a/test/libsolidity/syntaxTests/constants/mod_div_rational.sol
+++ b/test/libsolidity/syntaxTests/constants/mod_div_rational.sol
@@ -4,5 +4,7 @@ contract C {
     fixed a3 = 0 / 0.123;
     fixed a4 = 0 / -0.123;
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-150): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/constructor/nonabiv2_type_abstract.sol b/test/libsolidity/syntaxTests/constructor/nonabiv2_type_abstract.sol
index 2ca22790c128..ca52859ff928 100644
--- a/test/libsolidity/syntaxTests/constructor/nonabiv2_type_abstract.sol
+++ b/test/libsolidity/syntaxTests/constructor/nonabiv2_type_abstract.sol
@@ -2,4 +2,6 @@ pragma abicoder v1;
 abstract contract C {
 	constructor(uint[][][] memory t) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol b/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol
index 858b9132dd32..74a659cd8b83 100644
--- a/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol
+++ b/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol
@@ -32,6 +32,7 @@ contract C {
 // ====
 // EVMVersion: >=constantinople
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
 // Info 4164: (31-61): Inferred type: void
diff --git a/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol b/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol
index fc75e85947eb..72af2133f206 100644
--- a/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol
+++ b/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol
@@ -13,6 +13,7 @@ contract C
 // ====
 // EVMVersion: >=constantinople
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // 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.
diff --git a/test/libsolidity/syntaxTests/functionCalls/calloptions_duplicated.sol b/test/libsolidity/syntaxTests/functionCalls/calloptions_duplicated.sol
index 3b162a7f220a..417eea14d609 100644
--- a/test/libsolidity/syntaxTests/functionCalls/calloptions_duplicated.sol
+++ b/test/libsolidity/syntaxTests/functionCalls/calloptions_duplicated.sol
@@ -8,6 +8,8 @@ contract C {
     }
 }
 // ====
+// bytecodeFormat: legacy
+// ====
 // EVMVersion: >=constantinople
 // ----
 // TypeError 9886: (78-101): Duplicate option "gas".
diff --git a/test/libsolidity/syntaxTests/functionCalls/calloptions_on_delegatecall.sol b/test/libsolidity/syntaxTests/functionCalls/calloptions_on_delegatecall.sol
index d719fdcd9bb7..858b9a1d2e89 100644
--- a/test/libsolidity/syntaxTests/functionCalls/calloptions_on_delegatecall.sol
+++ b/test/libsolidity/syntaxTests/functionCalls/calloptions_on_delegatecall.sol
@@ -3,6 +3,8 @@ contract C {
         address(10).delegatecall{value: 7, gas: 3}("");
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 6189: (56-98): Cannot set option "value" for delegatecall.
 // Warning 9302: (56-102): Return value of low-level calls not used.
diff --git a/test/libsolidity/syntaxTests/functionCalls/calloptions_on_staticcall.sol b/test/libsolidity/syntaxTests/functionCalls/calloptions_on_staticcall.sol
index e128f03f1f21..c525542c7e0b 100644
--- a/test/libsolidity/syntaxTests/functionCalls/calloptions_on_staticcall.sol
+++ b/test/libsolidity/syntaxTests/functionCalls/calloptions_on_staticcall.sol
@@ -5,6 +5,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // TypeError 2842: (56-96): Cannot set option "value" for staticcall.
 // Warning 9302: (56-100): Return value of low-level calls not used.
diff --git a/test/libsolidity/syntaxTests/functionCalls/calloptions_repeated.sol b/test/libsolidity/syntaxTests/functionCalls/calloptions_repeated.sol
index 4356efcf95d5..0961881a1257 100644
--- a/test/libsolidity/syntaxTests/functionCalls/calloptions_repeated.sol
+++ b/test/libsolidity/syntaxTests/functionCalls/calloptions_repeated.sol
@@ -10,6 +10,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // TypeError 1645: (78-110): Function call options have already been set, you have to combine them into a single {...}-option.
 // TypeError 1645: (120-154): Function call options have already been set, you have to combine them into a single {...}-option.
diff --git a/test/libsolidity/syntaxTests/functionCalls/lowlevel_call_options.sol b/test/libsolidity/syntaxTests/functionCalls/lowlevel_call_options.sol
index da5c17a20ac0..c5ec6de71380 100644
--- a/test/libsolidity/syntaxTests/functionCalls/lowlevel_call_options.sol
+++ b/test/libsolidity/syntaxTests/functionCalls/lowlevel_call_options.sol
@@ -4,4 +4,6 @@ contract C {
         success;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/functionTypes/call_gas_on_function.sol b/test/libsolidity/syntaxTests/functionTypes/call_gas_on_function.sol
index 6b926e2ddecb..e92d1cfb0489 100644
--- a/test/libsolidity/syntaxTests/functionTypes/call_gas_on_function.sol
+++ b/test/libsolidity/syntaxTests/functionTypes/call_gas_on_function.sol
@@ -4,5 +4,6 @@ contract C {
         x{gas: 2}(1);
     }
 }
-
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol b/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol
index 12cbe2939bc3..14abf42cb9c1 100644
--- a/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol
+++ b/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol
@@ -7,6 +7,8 @@ contract C {
         );
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/functionTypes/external_functions_with_variable_number_of_stack_slots.sol b/test/libsolidity/syntaxTests/functionTypes/external_functions_with_variable_number_of_stack_slots.sol
index 8593bdbf4fed..96732043f214 100644
--- a/test/libsolidity/syntaxTests/functionTypes/external_functions_with_variable_number_of_stack_slots.sol
+++ b/test/libsolidity/syntaxTests/functionTypes/external_functions_with_variable_number_of_stack_slots.sol
@@ -3,6 +3,8 @@ contract C {
         this.f{gas: 42}.address;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 6321: (56-60): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
 // Warning 2018: (17-102): Function state mutability can be restricted to view
diff --git a/test/libsolidity/syntaxTests/immutable/creationCode.sol b/test/libsolidity/syntaxTests/immutable/creationCode.sol
index 0a2282695cda..32fb4edea8bb 100644
--- a/test/libsolidity/syntaxTests/immutable/creationCode.sol
+++ b/test/libsolidity/syntaxTests/immutable/creationCode.sol
@@ -7,4 +7,6 @@ contract Test {
         return type(A).creationCode;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/immutable/no_assignments.sol b/test/libsolidity/syntaxTests/immutable/no_assignments.sol
index 7d7948671419..889f6d395f6a 100644
--- a/test/libsolidity/syntaxTests/immutable/no_assignments.sol
+++ b/test/libsolidity/syntaxTests/immutable/no_assignments.sol
@@ -9,5 +9,6 @@ contract C {
 }
 // ====
 // optimize-yul: true
+// bytecodeFormat: legacy
 // ----
 // CodeGenerationError 1284: (0-168): Some immutables were read from but never assigned, possibly because of optimization.
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/assignment_from_library.sol b/test/libsolidity/syntaxTests/inlineAssembly/assignment_from_library.sol
index 522ca801d975..676677ea310a 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/assignment_from_library.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/assignment_from_library.sol
@@ -8,4 +8,6 @@ contract C {
     }
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/create2_as_variable_post_istanbul.sol b/test/libsolidity/syntaxTests/inlineAssembly/create2_as_variable_post_istanbul.sol
index 96a384c54d20..0468ef093f52 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/create2_as_variable_post_istanbul.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/create2_as_variable_post_istanbul.sol
@@ -6,4 +6,5 @@ contract c {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/evm_byzantium.sol b/test/libsolidity/syntaxTests/inlineAssembly/evm_byzantium.sol
index b08172ebe469..e019026f633b 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/evm_byzantium.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/evm_byzantium.sol
@@ -13,4 +13,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/evm_constantinople.sol b/test/libsolidity/syntaxTests/inlineAssembly/evm_constantinople.sol
index 2aff4351ae8b..ddfa80d7fc7e 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/evm_constantinople.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/evm_constantinople.sol
@@ -19,4 +19,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/extcodehash_as_variable_post_constantinople.sol b/test/libsolidity/syntaxTests/inlineAssembly/extcodehash_as_variable_post_constantinople.sol
index 8b34ab906d4a..8ee7f644be0e 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/extcodehash_as_variable_post_constantinople.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/extcodehash_as_variable_post_constantinople.sol
@@ -7,4 +7,5 @@ contract c {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/hex_switch_case.sol b/test/libsolidity/syntaxTests/inlineAssembly/hex_switch_case.sol
index 038e8c4ff99e..c9e7578c3ce7 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/hex_switch_case.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/hex_switch_case.sol
@@ -7,4 +7,6 @@ contract C {
     }
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/invalid/pc_disallowed.sol b/test/libsolidity/syntaxTests/inlineAssembly/invalid/pc_disallowed.sol
index 816bb1c0d5f4..1178e9a2b907 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/invalid/pc_disallowed.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/invalid/pc_disallowed.sol
@@ -5,5 +5,7 @@ contract C {
 		}
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // SyntaxError 2450: (61-63): PC instruction is a low-level EVM feature. Because of that PC is disallowed in strict assembly.
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/string_literal_switch_case.sol b/test/libsolidity/syntaxTests/inlineAssembly/string_literal_switch_case.sol
index 0a63987e143e..92ed08511686 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/string_literal_switch_case.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/string_literal_switch_case.sol
@@ -7,4 +7,6 @@ contract C {
     }
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inlineAssembly/use_msize_without_optimizer.sol b/test/libsolidity/syntaxTests/inlineAssembly/use_msize_without_optimizer.sol
index 8cdf96641ada..d356fe299ae9 100644
--- a/test/libsolidity/syntaxTests/inlineAssembly/use_msize_without_optimizer.sol
+++ b/test/libsolidity/syntaxTests/inlineAssembly/use_msize_without_optimizer.sol
@@ -7,4 +7,5 @@ contract C {
 }
 // ====
 // optimize-yul: false
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/inline_arrays/inline_array_fixed_types.sol b/test/libsolidity/syntaxTests/inline_arrays/inline_array_fixed_types.sol
index 8e51bd1886c1..3f3bf66b4564 100644
--- a/test/libsolidity/syntaxTests/inline_arrays/inline_array_fixed_types.sol
+++ b/test/libsolidity/syntaxTests/inline_arrays/inline_array_fixed_types.sol
@@ -3,6 +3,8 @@ contract test {
         fixed[3] memory a = [fixed(3.5), fixed(-4.25), fixed(967.125)];
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2072: (50-67): Unused local variable.
 // Warning 2018: (20-119): Function state mutability can be restricted to pure
diff --git a/test/libsolidity/syntaxTests/inline_arrays/inline_array_rationals.sol b/test/libsolidity/syntaxTests/inline_arrays/inline_array_rationals.sol
index 0382672fe38e..1f5b7abac56c 100644
--- a/test/libsolidity/syntaxTests/inline_arrays/inline_array_rationals.sol
+++ b/test/libsolidity/syntaxTests/inline_arrays/inline_array_rationals.sol
@@ -3,6 +3,8 @@ contract test {
         ufixed128x3[4] memory a = [ufixed128x3(3.5), 4.125, 2.5, 4.0];
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2072: (50-73): Unused local variable.
 // Warning 2018: (20-118): Function state mutability can be restricted to pure
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccess.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccess.sol
index e90443e14ef5..6136665e34bd 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccess.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccess.sol
@@ -9,4 +9,6 @@ contract Test {
 contract Other {
     function f(uint) public pure returns (uint) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractCreation.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractCreation.sol
index 2f5c356c08d0..22f81cfb0241 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractCreation.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractCreation.sol
@@ -6,5 +6,7 @@ contract Test {
 abstract contract Other {
     function f(uint) public returns (uint);
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 9582: (97-121): Member "creationCode" not found or not visible after argument-dependent lookup in type(contract Other).
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractRuntime.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractRuntime.sol
index 538a26e78941..8019dabb2176 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractRuntime.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessAbstractRuntime.sol
@@ -6,5 +6,7 @@ contract Test {
 abstract contract Other {
     function f(uint) public returns (uint);
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 9582: (91-114): Member "runtimeCode" not found or not visible after argument-dependent lookup in type(contract Other).
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessBase.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessBase.sol
index c202046cc4d0..c4b3efedd77d 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessBase.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessBase.sol
@@ -21,6 +21,8 @@ contract Test4 is Base {
         return type(Base).runtimeCode;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 7813: (166-190): Circular reference to contract bytecode either via "new" or "type(...).creationCode" / "type(...).runtimeCode".
 // TypeError 7813: (300-323): Circular reference to contract bytecode either via "new" or "type(...).creationCode" / "type(...).runtimeCode".
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessCyclic.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessCyclic.sol
index 57e3263e3249..4a5a760f792b 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessCyclic.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessCyclic.sol
@@ -8,6 +8,8 @@ contract B {
         type(A).runtimeCode;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 7813: (52-71): Circular reference to contract bytecode either via "new" or "type(...).creationCode" / "type(...).runtimeCode".
 // TypeError 7813: (133-152): Circular reference to contract bytecode either via "new" or "type(...).creationCode" / "type(...).runtimeCode".
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessIsConstant.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessIsConstant.sol
index cda5d5c349f7..96303396e032 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessIsConstant.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessIsConstant.sol
@@ -4,4 +4,6 @@ contract Test {
 
 }
 contract B { function f() public pure {} }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccessLibrary.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccessLibrary.sol
index f746dc35d1de..8c707006891b 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccessLibrary.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccessLibrary.sol
@@ -9,4 +9,6 @@ contract Test {
 contract Library {
     function f(uint) public pure returns (uint) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeAccess_super.sol b/test/libsolidity/syntaxTests/metaTypes/codeAccess_super.sol
index 7d057e132b17..a8fef765eea1 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeAccess_super.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeAccess_super.sol
@@ -9,5 +9,7 @@ contract SuperTest is Other {
 		return type(super).runtimeCode;
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 4259: (177-182): Invalid type for argument in the function call. An enum type, contract type or an integer type is required, but type(contract super SuperTest) provided.
diff --git a/test/libsolidity/syntaxTests/metaTypes/codeIsNoLValue.sol b/test/libsolidity/syntaxTests/metaTypes/codeIsNoLValue.sol
index c9cade179f55..2a51276414d9 100644
--- a/test/libsolidity/syntaxTests/metaTypes/codeIsNoLValue.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/codeIsNoLValue.sol
@@ -5,6 +5,8 @@ contract Test {
     }
 }
 contract C {}
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 4247: (55-75): Expression has to be an lvalue.
 // TypeError 4247: (100-119): Expression has to be an lvalue.
diff --git a/test/libsolidity/syntaxTests/metaTypes/runtimeCodeWarningAssembly.sol b/test/libsolidity/syntaxTests/metaTypes/runtimeCodeWarningAssembly.sol
index 40eaee040cbe..8e6fcf64e34a 100644
--- a/test/libsolidity/syntaxTests/metaTypes/runtimeCodeWarningAssembly.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/runtimeCodeWarningAssembly.sol
@@ -12,6 +12,8 @@ contract C {
 contract D is C {
     constructor() {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 6417: (77-96): 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.
 // Warning 6417: (118-137): 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.
diff --git a/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol b/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol
index 6b054b4dacfb..d110b2c8ec37 100644
--- a/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol
@@ -6,4 +6,6 @@ contract C {
         return type(A).runtimeCode;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol b/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol
index 8fcf65480e12..f802b9a00508 100644
--- a/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol
+++ b/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol
@@ -9,6 +9,8 @@ contract C {
         return (getA ? type(A) : type(B)).runtimeCode;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 9717: (126-133): Invalid mobile type in true expression.
 // TypeError 3703: (136-143): Invalid mobile type in false expression.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/303_fixed_type_int_conversion.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/303_fixed_type_int_conversion.sol
index 88a407fef98d..2ad042f13e6c 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/303_fixed_type_int_conversion.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/303_fixed_type_int_conversion.sol
@@ -7,6 +7,8 @@ contract test {
         c; d;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (20-147): Function state mutability can be restricted to pure
 // UnimplementedFeatureError 1834: (0-149): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/304_fixed_type_rational_int_conversion.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/304_fixed_type_rational_int_conversion.sol
index 0e3cb3b6cb47..7b79e70dafa0 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/304_fixed_type_rational_int_conversion.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/304_fixed_type_rational_int_conversion.sol
@@ -5,6 +5,8 @@ contract test {
         c; d;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (20-104): Function state mutability can be restricted to pure
 // UnimplementedFeatureError 1834: (0-106): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/305_fixed_type_rational_fraction_conversion.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/305_fixed_type_rational_fraction_conversion.sol
index ada627037e49..3a25255e5975 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/305_fixed_type_rational_fraction_conversion.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/305_fixed_type_rational_fraction_conversion.sol
@@ -5,6 +5,8 @@ contract test {
         a; d;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (20-108): Function state mutability can be restricted to pure
 // UnimplementedFeatureError 1834: (0-110): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/307_rational_unary_minus_operation.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/307_rational_unary_minus_operation.sol
index adb9fbe699ce..2c9d48aafc20 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/307_rational_unary_minus_operation.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/307_rational_unary_minus_operation.sol
@@ -5,5 +5,7 @@ contract test {
         a; b;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-126): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/312_leading_zero_rationals_convert.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/312_leading_zero_rationals_convert.sol
index e763fa18be20..87dc6191fe02 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/312_leading_zero_rationals_convert.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/312_leading_zero_rationals_convert.sol
@@ -7,5 +7,7 @@ contract A {
         a; b; c; d;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-289): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/314_fixed_type_zero_handling.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/314_fixed_type_zero_handling.sol
index b9205f01b1d9..799a56c60933 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/314_fixed_type_zero_handling.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/314_fixed_type_zero_handling.sol
@@ -4,6 +4,8 @@ contract test {
         ufixed32x1 b = 0; b;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (20-104): Function state mutability can be restricted to pure
 // UnimplementedFeatureError 1834: (0-106): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/317_fixed_type_valid_explicit_conversions.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/317_fixed_type_valid_explicit_conversions.sol
index 1282c24daf89..5ef69cf38fee 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/317_fixed_type_valid_explicit_conversions.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/317_fixed_type_valid_explicit_conversions.sol
@@ -5,6 +5,8 @@ contract test {
         ufixed8x1 c = ufixed8x1(1/3); c;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (20-182): Function state mutability can be restricted to pure
 // UnimplementedFeatureError 1834: (0-184): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/323_mapping_with_fixed_literal.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/323_mapping_with_fixed_literal.sol
index 3ee670cd585c..b3a861d79369 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/323_mapping_with_fixed_literal.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/323_mapping_with_fixed_literal.sol
@@ -4,5 +4,7 @@ contract test {
         fixedString[0.5] = "Half";
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-130): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/324_fixed_points_inside_structs.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/324_fixed_points_inside_structs.sol
index ba467a67b131..f3976b6f7754 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/324_fixed_points_inside_structs.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/324_fixed_points_inside_structs.sol
@@ -5,5 +5,7 @@ contract test {
     }
     myStruct a = myStruct(3.125, 3);
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-115): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/328_rational_to_fixed_literal_expression.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/328_rational_to_fixed_literal_expression.sol
index b5162bcd9720..988e0c53f788 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/328_rational_to_fixed_literal_expression.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/328_rational_to_fixed_literal_expression.sol
@@ -10,6 +10,8 @@ contract test {
         a; b; c; d; e; f; g;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2519: (238-252): This declaration shadows an existing declaration.
 // Warning 2018: (20-339): Function state mutability can be restricted to pure
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/343_integer_and_fixed_interaction.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/343_integer_and_fixed_interaction.sol
index 3ebd54d4541a..23cb58a620b8 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/343_integer_and_fixed_interaction.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/343_integer_and_fixed_interaction.sol
@@ -3,6 +3,8 @@ contract test {
         ufixed a = uint64(1) + ufixed(2);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2072: (50-58): Unused local variable.
 // Warning 2018: (20-89): Function state mutability can be restricted to pure
diff --git a/test/libsolidity/syntaxTests/nameAndTypeResolution/497_gasleft.sol b/test/libsolidity/syntaxTests/nameAndTypeResolution/497_gasleft.sol
index 3d5acac99be3..7a5254a1a127 100644
--- a/test/libsolidity/syntaxTests/nameAndTypeResolution/497_gasleft.sol
+++ b/test/libsolidity/syntaxTests/nameAndTypeResolution/497_gasleft.sol
@@ -1,4 +1,6 @@
 contract C {
     function f() public view returns (uint256 val) { return gasleft(); }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/parsing/lexer_numbers_with_underscores_fixed.sol b/test/libsolidity/syntaxTests/parsing/lexer_numbers_with_underscores_fixed.sol
index 9346264edbcd..5cd94502699b 100644
--- a/test/libsolidity/syntaxTests/parsing/lexer_numbers_with_underscores_fixed.sol
+++ b/test/libsolidity/syntaxTests/parsing/lexer_numbers_with_underscores_fixed.sol
@@ -6,5 +6,7 @@ contract C {
     f1; f2;
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-109): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol b/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol
index f22b9755d652..5ac74bba7cb7 100644
--- a/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol
+++ b/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol
@@ -8,5 +8,6 @@ contract test {
 }
 // ====
 // EVMVersion: >=cancun
+// bytecodeFormat: legacy
 // ----
 // Warning 5574: (21-27154): Contract code size is 27164 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/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol b/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol
index a0c7267d0d20..f3091ebf5351 100644
--- a/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol
+++ b/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol
@@ -8,5 +8,6 @@ contract test {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/specialFunctions/functionCallOptions_err.sol b/test/libsolidity/syntaxTests/specialFunctions/functionCallOptions_err.sol
index 071859e53fb7..8e5ebcdeb97a 100644
--- a/test/libsolidity/syntaxTests/specialFunctions/functionCallOptions_err.sol
+++ b/test/libsolidity/syntaxTests/specialFunctions/functionCallOptions_err.sol
@@ -5,6 +5,8 @@ contract C {
 		abi.encode(this.f{value: 2, gas: 1});
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 2056: (60-76): This type cannot be encoded.
 // TypeError 2056: (92-106): This type cannot be encoded.
diff --git a/test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_internal_functions.sol b/test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_internal_functions.sol
index 6ecb4e4ff869..5ad39fe9f7b9 100644
--- a/test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_internal_functions.sol
+++ b/test/libsolidity/syntaxTests/specialFunctions/types_with_unspecified_encoding_internal_functions.sol
@@ -4,6 +4,8 @@ contract C {
         h;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 2056: (91-100): This type cannot be encoded.
 // TypeError 2056: (102-103): This type cannot be encoded.
diff --git a/test/libsolidity/syntaxTests/types/address/address_members.sol b/test/libsolidity/syntaxTests/types/address/address_members.sol
index 144361b9409a..9299b65d523c 100644
--- a/test/libsolidity/syntaxTests/types/address/address_members.sol
+++ b/test/libsolidity/syntaxTests/types/address/address_members.sol
@@ -5,4 +5,6 @@ contract C {
     function i() public view returns (uint) { return f().code.length; }
     function j() public view returns (uint) { return h().length; }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol b/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol
index 754ff2c67488..449b628d4491 100644
--- a/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol
+++ b/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol
@@ -3,5 +3,7 @@ contract C {
         selfdestruct(a);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/types/address/codehash.sol b/test/libsolidity/syntaxTests/types/address/codehash.sol
index cf7eaabec976..00956d97e848 100644
--- a/test/libsolidity/syntaxTests/types/address/codehash.sol
+++ b/test/libsolidity/syntaxTests/types/address/codehash.sol
@@ -5,4 +5,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/types/rational_number_literal_to_fixed_implicit.sol b/test/libsolidity/syntaxTests/types/rational_number_literal_to_fixed_implicit.sol
index e62728770d90..18bb56b6d17a 100644
--- a/test/libsolidity/syntaxTests/types/rational_number_literal_to_fixed_implicit.sol
+++ b/test/libsolidity/syntaxTests/types/rational_number_literal_to_fixed_implicit.sol
@@ -12,5 +12,7 @@ contract C {
         a; b; c;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // UnimplementedFeatureError 1834: (0-317): Not yet implemented - FixedPointType.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/address_constantinople.sol b/test/libsolidity/syntaxTests/viewPureChecker/address_constantinople.sol
index 4387ca60a75b..e8ee980bf5ac 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/address_constantinople.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/address_constantinople.sol
@@ -8,4 +8,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/assembly.sol b/test/libsolidity/syntaxTests/viewPureChecker/assembly.sol
index cc8ac5e8341b..9097a166c118 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/assembly.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/assembly.sol
@@ -27,4 +27,6 @@ contract C {
         assembly { pop(extcodesize(0)) }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/assembly_constantinople.sol b/test/libsolidity/syntaxTests/viewPureChecker/assembly_constantinople.sol
index ed0b20d53793..16f57b2e8091 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/assembly_constantinople.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/assembly_constantinople.sol
@@ -5,4 +5,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol b/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol
index 4d1710a3a160..8f275321382a 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol
@@ -18,5 +18,7 @@ contract C {
     }
     receive() payable external {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_restrict_warning.sol b/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_restrict_warning.sol
index 858bcac446b2..15793d60fccf 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_restrict_warning.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_restrict_warning.sol
@@ -16,6 +16,8 @@ contract C {
         x; y; z;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Warning 2018: (17-288): Function state mutability can be restricted to pure
 // Warning 2018: (293-559): Function state mutability can be restricted to pure
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/gas_value_without_call.sol b/test/libsolidity/syntaxTests/viewPureChecker/gas_value_without_call.sol
index 41120bf08111..f0bfba70ce31 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/gas_value_without_call.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/gas_value_without_call.sol
@@ -11,4 +11,6 @@ contract C {
 		this.f{gas: 42};
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/gas_with_call_nonpayable.sol b/test/libsolidity/syntaxTests/viewPureChecker/gas_with_call_nonpayable.sol
index 65030cb30729..77956ffac02a 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/gas_with_call_nonpayable.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/gas_with_call_nonpayable.sol
@@ -7,6 +7,8 @@ contract C {
 		this.h{gas: 42}();
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 8961: (90-109): Function cannot be declared as view because this expression (potentially) modifies the state.
 // TypeError 8961: (180-197): Function cannot be declared as view because this expression (potentially) modifies the state.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol
index 886d6de0ce2f..680a8f85f2f7 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol
@@ -84,6 +84,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=paris
+// bytecodeFormat: legacy
 // ----
 // 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.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol
index 16c75d6f7291..5268f7a98e0b 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol
@@ -83,6 +83,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=london
+// bytecodeFormat: legacy
 // ----
 // Warning 5740: (94-1755): Unreachable code.
 // Warning 5740: (1768-1780): Unreachable code.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol
index 0bb92c1fd2fa..e2fa70102dfa 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol
@@ -84,6 +84,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=paris
+// bytecodeFormat: legacy
 // ----
 // Warning 5740: (94-1733): Unreachable code.
 // Warning 5740: (1746-1758): Unreachable code.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed.sol
index 992a51ad2a28..ff557e6865f7 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed.sol
@@ -15,6 +15,8 @@ contract C {
         }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // SyntaxError 6553: (47-362): The msize instruction cannot be used when the Yul optimizer is activated because it can change its semantics. Either disable the Yul optimizer or do not use the instruction.
 // DeclarationError 4619: (70-78): Function "datasize" not found.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol
index 665a17eebf63..91be09f58f22 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol
@@ -34,6 +34,8 @@ contract C {
         }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // 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.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol
index f0320d8b0835..ded86c88a9a3 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol
@@ -7,5 +7,6 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol
index 30210efc32fa..47826724e8e6 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol
@@ -8,6 +8,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // 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/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol
index b2f241ff08c5..e2bf4c5d1f4b 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol
@@ -22,6 +22,7 @@ contract C {
 }
 // ====
 // EVMVersion: >=london
+// bytecodeFormat: legacy
 // ----
 // 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.
diff --git a/test/libsolidity/syntaxTests/viewPureChecker/staticcall_gas_view.sol b/test/libsolidity/syntaxTests/viewPureChecker/staticcall_gas_view.sol
index f49327a92114..832f60f97b56 100644
--- a/test/libsolidity/syntaxTests/viewPureChecker/staticcall_gas_view.sol
+++ b/test/libsolidity/syntaxTests/viewPureChecker/staticcall_gas_view.sol
@@ -8,4 +8,5 @@ contract C {
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/objectCompiler/data.yul b/test/libyul/objectCompiler/data.yul
index 4447a0b8e97f..643bd1c34bda 100644
--- a/test/libyul/objectCompiler/data.yul
+++ b/test/libyul/objectCompiler/data.yul
@@ -5,6 +5,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":22:29   */
diff --git a/test/libyul/objectCompiler/datacopy.yul b/test/libyul/objectCompiler/datacopy.yul
index 46a0ec0f7a6d..ea00b4478461 100644
--- a/test/libyul/objectCompiler/datacopy.yul
+++ b/test/libyul/objectCompiler/datacopy.yul
@@ -13,6 +13,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":77:92   */
diff --git a/test/libyul/objectCompiler/dataoffset_code.yul b/test/libyul/objectCompiler/dataoffset_code.yul
index 1171303af291..2a1aa04a14dd 100644
--- a/test/libyul/objectCompiler/dataoffset_code.yul
+++ b/test/libyul/objectCompiler/dataoffset_code.yul
@@ -7,6 +7,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":44:61   */
diff --git a/test/libyul/objectCompiler/dataoffset_data.yul b/test/libyul/objectCompiler/dataoffset_data.yul
index 381cb999f0ed..9490986819e0 100644
--- a/test/libyul/objectCompiler/dataoffset_data.yul
+++ b/test/libyul/objectCompiler/dataoffset_data.yul
@@ -4,6 +4,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":56:75   */
diff --git a/test/libyul/objectCompiler/dataoffset_self.yul b/test/libyul/objectCompiler/dataoffset_self.yul
index b6a0552cb7b1..9f82f5568023 100644
--- a/test/libyul/objectCompiler/dataoffset_self.yul
+++ b/test/libyul/objectCompiler/dataoffset_self.yul
@@ -4,6 +4,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":44:59   */
diff --git a/test/libyul/objectCompiler/datasize_code.yul b/test/libyul/objectCompiler/datasize_code.yul
index 7bf365031b5b..db2fee4d8392 100644
--- a/test/libyul/objectCompiler/datasize_code.yul
+++ b/test/libyul/objectCompiler/datasize_code.yul
@@ -7,6 +7,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":44:59   */
diff --git a/test/libyul/objectCompiler/datasize_data.yul b/test/libyul/objectCompiler/datasize_data.yul
index f0ae32b1b661..52afde6fcad0 100644
--- a/test/libyul/objectCompiler/datasize_data.yul
+++ b/test/libyul/objectCompiler/datasize_data.yul
@@ -4,6 +4,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":44:61   */
diff --git a/test/libyul/objectCompiler/datasize_self.yul b/test/libyul/objectCompiler/datasize_self.yul
index fb5b7fb89489..93512f1da5ac 100644
--- a/test/libyul/objectCompiler/datasize_self.yul
+++ b/test/libyul/objectCompiler/datasize_self.yul
@@ -4,6 +4,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":36:49   */
diff --git a/test/libyul/objectCompiler/eof/identical_subobjects_creation_deployed.yul b/test/libyul/objectCompiler/eof/identical_subobjects_creation_deployed.yul
new file mode 100644
index 000000000000..ad5c16a6cf57
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/identical_subobjects_creation_deployed.yul
@@ -0,0 +1,109 @@
+// All objects have identical unoptimized code, but at 200 runs the creation objects will optimized
+// differently from deployed objects.
+
+/// @use-src 0:"A.sol"
+object "A" {
+    code {
+        function load(i) -> r { r := calldataload(i) }
+        let x := add(shl(255, 1), shl(127, not(0)))
+        sstore(load(x), load(1))
+    }
+
+    /// @use-src 0:"B.sol"
+    object "B_deployed" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            let x := add(shl(255, 1), shl(127, not(0)))
+            sstore(load(x), load(1))
+        }
+
+        /// @use-src 0:"A.sol"
+        object "A" {
+            code {
+                function load(i) -> r { r := calldataload(i) }
+                let x := add(shl(255, 1), shl(127, not(0)))
+                sstore(load(x), load(1))
+            }
+
+            /// @use-src 0:"B.sol"
+            object "B_deployed" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    let x := add(shl(255, 1), shl(127, not(0)))
+                    sstore(load(x), load(1))
+                }
+            }
+
+            /// @use-src 0:"C.sol"
+            object "C" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    let x := add(shl(255, 1), shl(127, not(0)))
+                    sstore(load(x), load(1))
+                }
+            }
+        }
+    }
+
+    /// @use-src 0:"C.sol"
+    object "C_deployed" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            let x := add(shl(255, 1), shl(127, not(0)))
+            sstore(load(x), load(1))
+        }
+    }
+
+    /// @use-src 0:"D.sol"
+    object "D" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            let x := add(shl(255, 1), shl(127, not(0)))
+            sstore(load(x), load(1))
+        }
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//   sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01))
+//   stop
+// stop
+//
+// sub_0: assembly {
+//       sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01))
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//           sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01))
+//           stop
+//         stop
+//
+//         sub_0: assembly {
+//               sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01))
+//               stop
+//         }
+//
+//         sub_1: assembly {
+//               sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01))
+//               stop
+//         }
+//     }
+// }
+//
+// sub_1: assembly {
+//       sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01))
+//       stop
+// }
+//
+// sub_2: assembly {
+//       sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01))
+//       stop
+// }
+// Bytecode: ef0001010004020001001104000000008000046001356001607f1b600160ff1b03355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP GT DIV STOP STOP STOP STOP DUP1 STOP DIV PUSH1 0x1 CALLDATALOAD PUSH1 0x1 PUSH1 0x7F SHL PUSH1 0x1 PUSH1 0xFF SHL SUB CALLDATALOAD SSTORE STOP
+// SourceMappings: :::-:0;;;;;;;;;;;
diff --git a/test/libyul/objectCompiler/eof/identical_subobjects_full_debug_info.yul b/test/libyul/objectCompiler/eof/identical_subobjects_full_debug_info.yul
new file mode 100644
index 000000000000..a580300d4be8
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/identical_subobjects_full_debug_info.yul
@@ -0,0 +1,116 @@
+// All objects have identical unoptimized code, but with different debug annotations.
+// The optimized Yul will be identical only between objects that have identical debug info.
+
+/// @use-src 0:"A.sol"
+object "A" {
+    code {
+        function load(i) -> r { r := calldataload(i) }
+        /// @src 0:10:20
+        sstore(load(0), load(1))
+    }
+
+    /// @use-src 0:"B.sol"
+    object "B" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+
+        /// @use-src 0:"A.sol"
+        object "A" {
+            code {
+                function load(i) -> r { r := calldataload(i) }
+                /// @src 0:10:20
+                sstore(load(0), load(1))
+            }
+
+            /// @use-src 0:"B.sol"
+            object "B" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    /// @src 0:10:20
+                    sstore(load(0), load(1))
+                }
+            }
+
+            /// @use-src 0:"C.sol"
+            object "C" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    /// @src 0:10:20
+                    sstore(load(0), load(1))
+                }
+            }
+        }
+    }
+
+    /// @use-src 0:"C.sol"
+    object "C" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+
+    /// @use-src 0:"D.sol"
+    object "D" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "A.sol":10:20   */
+//   sstore(calldataload(0x00), calldataload(0x01))
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "B.sol":10:20   */
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "A.sol":10:20   */
+//           sstore(calldataload(0x00), calldataload(0x01))
+//           stop
+//         stop
+//
+//         sub_0: assembly {
+//                 /* "B.sol":10:20   */
+//               sstore(calldataload(0x00), calldataload(0x01))
+//               stop
+//         }
+//
+//         sub_1: assembly {
+//                 /* "C.sol":10:20   */
+//               sstore(calldataload(0x00), calldataload(0x01))
+//               stop
+//         }
+//     }
+// }
+//
+// sub_1: assembly {
+//         /* "C.sol":10:20   */
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+// }
+//
+// sub_2: assembly {
+//         /* "D.sol":10:20   */
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+// }
+// Bytecode: ef0001010004020001000704000000008000026001355f355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SMOD DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 CALLDATALOAD PUSH0 CALLDATALOAD SSTORE STOP
+// SourceMappings: 10:10::-:0;-1:-1;10:10;-1:-1;10:10;-1:-1
diff --git a/test/libyul/objectCompiler/eof/identical_subobjects_no_debug_info.yul b/test/libyul/objectCompiler/eof/identical_subobjects_no_debug_info.yul
new file mode 100644
index 000000000000..681d2d7c013f
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/identical_subobjects_no_debug_info.yul
@@ -0,0 +1,165 @@
+// All objects have identical unoptimized code.
+// After optimizations we should end up with identical code for all of them.
+
+object "A" {
+    code {
+        function load(i) -> r { r := calldataload(i) }
+        sstore(load(0), load(1))
+    }
+
+    object "B" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            sstore(load(0), load(1))
+        }
+
+        object "A" {
+            code {
+                function load(i) -> r { r := calldataload(i) }
+                sstore(load(0), load(1))
+            }
+
+            object "B" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    sstore(load(0), load(1))
+                }
+            }
+
+            object "C" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    sstore(load(0), load(1))
+                }
+            }
+        }
+    }
+
+    object "C" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            sstore(load(0), load(1))
+        }
+    }
+
+    object "D" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            sstore(load(0), load(1))
+        }
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":83:84   */
+//   0x01
+//     /* "source":70:85   */
+//   calldataload
+//     /* "source":66:67   */
+//   0x00
+//     /* "source":53:68   */
+//   calldataload
+//     /* "source":46:86   */
+//   sstore
+//     /* "source":22:102   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":202:203   */
+//       0x01
+//         /* "source":189:204   */
+//       calldataload
+//         /* "source":185:186   */
+//       0x00
+//         /* "source":172:187   */
+//       calldataload
+//         /* "source":165:205   */
+//       sstore
+//         /* "source":133:229   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":345:346   */
+//           0x01
+//             /* "source":332:347   */
+//           calldataload
+//             /* "source":328:329   */
+//           0x00
+//             /* "source":315:330   */
+//           calldataload
+//             /* "source":308:348   */
+//           sstore
+//             /* "source":268:380   */
+//           stop
+//         stop
+//
+//         sub_0: assembly {
+//                 /* "source":512:513   */
+//               0x01
+//                 /* "source":499:514   */
+//               calldataload
+//                 /* "source":495:496   */
+//               0x00
+//                 /* "source":482:497   */
+//               calldataload
+//                 /* "source":475:515   */
+//               sstore
+//                 /* "source":427:555   */
+//               stop
+//         }
+//
+//         sub_1: assembly {
+//                 /* "source":701:702   */
+//               0x01
+//                 /* "source":688:703   */
+//               calldataload
+//                 /* "source":684:685   */
+//               0x00
+//                 /* "source":671:686   */
+//               calldataload
+//                 /* "source":664:704   */
+//               sstore
+//                 /* "source":616:744   */
+//               stop
+//         }
+//     }
+// }
+//
+// sub_1: assembly {
+//         /* "source":874:875   */
+//       0x01
+//         /* "source":861:876   */
+//       calldataload
+//         /* "source":857:858   */
+//       0x00
+//         /* "source":844:859   */
+//       calldataload
+//         /* "source":837:877   */
+//       sstore
+//         /* "source":805:901   */
+//       stop
+// }
+//
+// sub_2: assembly {
+//         /* "source":1007:1008   */
+//       0x01
+//         /* "source":994:1009   */
+//       calldataload
+//         /* "source":990:991   */
+//       0x00
+//         /* "source":977:992   */
+//       calldataload
+//         /* "source":970:1010   */
+//       sstore
+//         /* "source":938:1034   */
+//       stop
+// }
+// Bytecode: ef0001010004020001000704000000008000026001355f355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SMOD DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 CALLDATALOAD PUSH0 CALLDATALOAD SSTORE STOP
+// SourceMappings: 83:1:0:-:0;70:15;66:1;53:15;46:40;22:80
diff --git a/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info.yul b/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info.yul
new file mode 100644
index 000000000000..27d24867c2ff
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info.yul
@@ -0,0 +1,153 @@
+// All objects have identical unoptimized code, but don't necessarily contain the same location comments.
+// The optimized Yul will be identical only between objects that have identical debug info.
+// Note that when @use-src is missing, the parser ignores location comments, so they do not become
+// a part of the debug info.
+
+/// @use-src 0:"A.sol"
+object "A" {
+    code {
+        function load(i) -> r { r := calldataload(i) }
+        /// @src 0:10:20
+        sstore(load(0), load(1))
+    }
+
+    /// @use-src 0:"B.sol"
+    object "B" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+
+        object "A" {
+            code {
+                function load(i) -> r { r := calldataload(i) }
+                sstore(load(0), load(1))
+            }
+
+            object "B" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    sstore(load(0), load(1))
+                }
+            }
+
+            /// @use-src 0:"C.sol"
+            object "C" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    /// @src 0:10:20
+                    sstore(load(0), load(1))
+                }
+            }
+        }
+    }
+
+    /// @use-src 0:"C.sol"
+    object "C" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+
+    /// @use-src 0:"C.sol"
+    object "D" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            sstore(load(0), load(1))
+        }
+    }
+
+    object "E" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "A.sol":10:20   */
+//   sstore(calldataload(0x00), calldataload(0x01))
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "B.sol":10:20   */
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":621:622   */
+//           0x01
+//             /* "source":608:623   */
+//           calldataload
+//             /* "source":604:605   */
+//           0x00
+//             /* "source":591:606   */
+//           calldataload
+//             /* "source":584:624   */
+//           sstore
+//             /* "source":544:656   */
+//           stop
+//         stop
+//
+//         sub_0: assembly {
+//                 /* "source":788:789   */
+//               0x01
+//                 /* "source":775:790   */
+//               calldataload
+//                 /* "source":771:772   */
+//               0x00
+//                 /* "source":758:773   */
+//               calldataload
+//                 /* "source":751:791   */
+//               sstore
+//                 /* "source":703:831   */
+//               stop
+//         }
+//
+//         sub_1: assembly {
+//                 /* "C.sol":10:20   */
+//               sstore(calldataload(0x00), calldataload(0x01))
+//               stop
+//         }
+//     }
+// }
+//
+// sub_1: assembly {
+//         /* "C.sol":10:20   */
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+// }
+//
+// sub_2: assembly {
+//       sstore(calldataload(0x00), calldataload(0x01))
+//       stop
+// }
+//
+// sub_3: assembly {
+//         /* "source":1743:1744   */
+//       0x01
+//         /* "source":1730:1745   */
+//       calldataload
+//         /* "source":1726:1727   */
+//       0x00
+//         /* "source":1713:1728   */
+//       calldataload
+//         /* "source":1706:1746   */
+//       sstore
+//         /* "source":1674:1770   */
+//       stop
+// }
+// Bytecode: ef0001010004020001000704000000008000026001355f355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SMOD DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 CALLDATALOAD PUSH0 CALLDATALOAD SSTORE STOP
+// SourceMappings: 10:10::-:0;-1:-1;10:10;-1:-1;10:10;-1:-1
diff --git a/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info_no_use_src.yul b/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info_no_use_src.yul
new file mode 100644
index 000000000000..d5f9ce544592
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/identical_subobjects_partial_debug_info_no_use_src.yul
@@ -0,0 +1,171 @@
+// All objects have identical unoptimized code, but don't necessarily contain the same location comments.
+// After optimizations we should end up with identical code for all of them, because location
+// comments will be ignored due to missing @use-src annotations and won't end up in the AST.
+
+object "A" {
+    code {
+        function load(i) -> r { r := calldataload(i) }
+        /// @src 0:10:20
+        sstore(load(0), load(1))
+    }
+
+    object "B" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+
+        object "A" {
+            code {
+                function load(i) -> r { r := calldataload(i) }
+                sstore(load(0), load(1))
+            }
+
+            object "B" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    sstore(load(0), load(1))
+                }
+            }
+
+            object "C" {
+                code {
+                    function load(i) -> r { r := calldataload(i) }
+                    /// @src 0:10:20
+                    sstore(load(0), load(1))
+                }
+            }
+        }
+    }
+
+    object "C" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+
+    object "D" {
+        code {
+            function load(i) -> r { r := calldataload(i) }
+            /// @src 0:10:20
+            sstore(load(0), load(1))
+        }
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":83:84   */
+//   0x01
+//     /* "source":70:85   */
+//   calldataload
+//     /* "source":66:67   */
+//   0x00
+//     /* "source":53:68   */
+//   calldataload
+//     /* "source":46:86   */
+//   sstore
+//     /* "source":22:102   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":202:203   */
+//       0x01
+//         /* "source":189:204   */
+//       calldataload
+//         /* "source":185:186   */
+//       0x00
+//         /* "source":172:187   */
+//       calldataload
+//         /* "source":165:205   */
+//       sstore
+//         /* "source":133:229   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":345:346   */
+//           0x01
+//             /* "source":332:347   */
+//           calldataload
+//             /* "source":328:329   */
+//           0x00
+//             /* "source":315:330   */
+//           calldataload
+//             /* "source":308:348   */
+//           sstore
+//             /* "source":268:380   */
+//           stop
+//         stop
+//
+//         sub_0: assembly {
+//                 /* "source":512:513   */
+//               0x01
+//                 /* "source":499:514   */
+//               calldataload
+//                 /* "source":495:496   */
+//               0x00
+//                 /* "source":482:497   */
+//               calldataload
+//                 /* "source":475:515   */
+//               sstore
+//                 /* "source":427:555   */
+//               stop
+//         }
+//
+//         sub_1: assembly {
+//                 /* "source":701:702   */
+//               0x01
+//                 /* "source":688:703   */
+//               calldataload
+//                 /* "source":684:685   */
+//               0x00
+//                 /* "source":671:686   */
+//               calldataload
+//                 /* "source":664:704   */
+//               sstore
+//                 /* "source":616:744   */
+//               stop
+//         }
+//     }
+// }
+//
+// sub_1: assembly {
+//         /* "source":874:875   */
+//       0x01
+//         /* "source":861:876   */
+//       calldataload
+//         /* "source":857:858   */
+//       0x00
+//         /* "source":844:859   */
+//       calldataload
+//         /* "source":837:877   */
+//       sstore
+//         /* "source":805:901   */
+//       stop
+// }
+//
+// sub_2: assembly {
+//         /* "source":1007:1008   */
+//       0x01
+//         /* "source":994:1009   */
+//       calldataload
+//         /* "source":990:991   */
+//       0x00
+//         /* "source":977:992   */
+//       calldataload
+//         /* "source":970:1010   */
+//       sstore
+//         /* "source":938:1034   */
+//       stop
+// }
+// Bytecode: ef0001010004020001000704000000008000026001355f355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SMOD DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 CALLDATALOAD PUSH0 CALLDATALOAD SSTORE STOP
+// SourceMappings: 83:1:0:-:0;70:15;66:1;53:15;46:40;22:80
diff --git a/test/libyul/objectCompiler/eof/leading_and_trailing_dots.yul b/test/libyul/objectCompiler/eof/leading_and_trailing_dots.yul
new file mode 100644
index 000000000000..a89ea3689039
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/leading_and_trailing_dots.yul
@@ -0,0 +1,33 @@
+{
+    function e(_._) {
+        e(0)
+    }
+    e(2)
+    function f(n._) {
+        f(0)
+    }
+    f(2)
+    function g(_.n) {
+        g(0)
+    }
+    g(2)
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":53:54   */
+//   0x02
+//     /* "source":51:55   */
+//   jumpf{code_section_1}
+//
+// code_section_1: assembly {
+//         /* "source":136:137   */
+//       0x00
+//         /* "source":134:138   */
+//       jumpf{code_section_1}
+// }
+// Bytecode: ef0001010008020002000500040400000000800001018000026002e500015fe50001
+// Opcodes: 0xEF STOP ADD ADD STOP ADDMOD MUL STOP MUL STOP SDIV STOP DIV DIV STOP STOP STOP STOP DUP1 STOP ADD ADD DUP1 STOP MUL PUSH1 0x2 JUMPF 0x1 PUSH0 JUMPF 0x1
+// SourceMappings: 53:1:0:-:0;51:4::i136:1:0:-:0;134:4::i
diff --git a/test/libyul/objectCompiler/eof/linkersymbol.yul b/test/libyul/objectCompiler/eof/linkersymbol.yul
new file mode 100644
index 000000000000..30a5a20e8b7e
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/linkersymbol.yul
@@ -0,0 +1,38 @@
+object "a" {
+    code {
+        let addr := linkersymbol("contract/test.sol:L")
+        mstore(128, shl(227, 0x18530aaf))
+        let success := extcall(addr, 0, 128, 4)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":178:179   */
+//   0x04
+//     /* "source":173:176   */
+//   0x80
+//     /* "source":170:171   */
+//   0x00
+//     /* "source":58:93   */
+//   linkerSymbol("f919ba91ac99f96129544b80b9516b27a80e376b9dc693819d0b18b7e0395612")
+//     /* "source":127:137   */
+//   0x18530aaf
+//     /* "source":122:125   */
+//   0xe3
+//     /* "source":118:138   */
+//   shl
+//     /* "source":106:139   */
+//   dup4
+//   mstore
+//     /* "source":156:180   */
+//   extcall
+//     /* "source":152:181   */
+//   pop
+//     /* "source":22:197   */
+//   stop
+// Bytecode: ef000101000402000100270400000000800006600460805f7300000000000000000000000000000000000000006318530aaf60e31b8352f85000
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP 0x27 DIV STOP STOP STOP STOP DUP1 STOP MOD PUSH1 0x4 PUSH1 0x80 PUSH0 PUSH20 0x0 PUSH4 0x18530AAF PUSH1 0xE3 SHL DUP4 MSTORE EXTCALL POP STOP
+// SourceMappings: 178:1:0:-:0;173:3;170:1;58:35;127:10;122:3;118:20;106:33;;156:24;152:29;22:175
diff --git a/test/libyul/objectCompiler/eof/namedObject.yul b/test/libyul/objectCompiler/eof/namedObject.yul
new file mode 100644
index 000000000000..05007d3dfc1a
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/namedObject.yul
@@ -0,0 +1,13 @@
+object "a" {
+  code {}
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":22:29   */
+//   stop
+// Bytecode: ef00010100040200010001040000000080000000
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP ADD DIV STOP STOP STOP STOP DUP1 STOP STOP STOP
+// SourceMappings: 22:7:0:-:0
diff --git a/test/libyul/objectCompiler/eof/namedObjectCode.yul b/test/libyul/objectCompiler/eof/namedObjectCode.yul
new file mode 100644
index 000000000000..8e82614ca8c9
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/namedObjectCode.yul
@@ -0,0 +1,19 @@
+object "a" {
+  code { sstore(0, 1) }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":36:37   */
+//   0x01
+//     /* "source":33:34   */
+//   0x00
+//     /* "source":26:38   */
+//   sstore
+//     /* "source":22:42   */
+//   stop
+// Bytecode: ef00010100040200010005040000000080000260015f5500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SDIV DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 PUSH0 SSTORE STOP
+// SourceMappings: 36:1:0:-:0;33;26:12;22:20
diff --git a/test/libyul/objectCompiler/eof/nested_optimizer.yul b/test/libyul/objectCompiler/eof/nested_optimizer.yul
new file mode 100644
index 000000000000..df0e74f01d3f
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/nested_optimizer.yul
@@ -0,0 +1,47 @@
+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)
+    }
+  }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":58:59   */
+//   0x00
+//     /* "source":41:56   */
+//   dup1
+//   calldataload
+//     /* "source":34:60   */
+//   sstore
+//     /* "source":22:68   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":141:142   */
+//       0x00
+//         /* "source":124:139   */
+//       dup1
+//       calldataload
+//         /* "source":117:143   */
+//       sstore
+//         /* "source":101:155   */
+//       stop
+// }
+// Bytecode: ef0001010004020001000504000000008000025f80355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SDIV DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH0 DUP1 CALLDATALOAD SSTORE STOP
+// SourceMappings: 58:1:0:-:0;41:15;;34:26;22:46
diff --git a/test/libyul/objectCompiler/eof/simple.yul b/test/libyul/objectCompiler/eof/simple.yul
new file mode 100644
index 000000000000..cfb95fbecfb1
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/simple.yul
@@ -0,0 +1,19 @@
+{
+  sstore(0, 1)
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":41:42   */
+//   0x01
+//     /* "source":38:39   */
+//   0x00
+//     /* "source":31:43   */
+//   sstore
+//     /* "source":27:47   */
+//   stop
+// Bytecode: ef00010100040200010005040000000080000260015f5500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SDIV DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH1 0x1 PUSH0 SSTORE STOP
+// SourceMappings: 41:1:0:-:0;38;31:12;27:20
diff --git a/test/libyul/objectCompiler/eof/simple_optimizer.yul b/test/libyul/objectCompiler/eof/simple_optimizer.yul
new file mode 100644
index 000000000000..c1d56a8402df
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/simple_optimizer.yul
@@ -0,0 +1,24 @@
+{
+  let x := calldataload(0)
+  let y := calldataload(0)
+  let z := sub(y, x)
+  sstore(add(x, 0), z)
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":63:64   */
+//   0x00
+//     /* "source":46:61   */
+//   dup1
+//   calldataload
+//     /* "source":39:65   */
+//   sstore
+//     /* "source":27:73   */
+//   stop
+// Bytecode: ef0001010004020001000504000000008000025f80355500
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP SDIV DIV STOP STOP STOP STOP DUP1 STOP MUL PUSH0 DUP1 CALLDATALOAD SSTORE STOP
+// SourceMappings: 63:1:0:-:0;46:15;;39:26;27:46
diff --git a/test/libyul/objectCompiler/eof/smoke.yul b/test/libyul/objectCompiler/eof/smoke.yul
new file mode 100644
index 000000000000..eecfac9a8741
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/smoke.yul
@@ -0,0 +1,12 @@
+{
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":27:34   */
+//   stop
+// Bytecode: ef00010100040200010001040000000080000000
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP ADD DIV STOP STOP STOP STOP DUP1 STOP STOP STOP
+// SourceMappings: 27:7:0:-:0
diff --git a/test/libyul/objectCompiler/eof/subObject.yul b/test/libyul/objectCompiler/eof/subObject.yul
new file mode 100644
index 000000000000..dd6cce28668c
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/subObject.yul
@@ -0,0 +1,29 @@
+object "a" {
+  code {}
+  // Unreferenced data is not added to the assembled bytecode.
+  data "str" "Hello, World!"
+  object "sub" { code { sstore(0, 1) } }
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":22:29   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+//
+// sub_0: assembly {
+//         /* "source":123:124   */
+//       0x01
+//         /* "source":120:121   */
+//       0x00
+//         /* "source":113:125   */
+//       sstore
+//         /* "source":109:129   */
+//       stop
+// }
+// Bytecode: ef0001010004020001000104000d00008000000048656c6c6f2c20576f726c6421
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP ADD DIV STOP 0xD STOP STOP DUP1 STOP STOP STOP BASEFEE PUSH6 0x6C6C6F2C2057 PUSH16 0x726C6421000000000000000000000000
+// SourceMappings: 22:7:0:-:0
diff --git a/test/libyul/objectCompiler/eof/subSubObject.yul b/test/libyul/objectCompiler/eof/subSubObject.yul
new file mode 100644
index 000000000000..39acf1f1d953
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/subSubObject.yul
@@ -0,0 +1,49 @@
+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"
+    }
+  }
+}
+// ====
+// EVMVersion: >=constantinople
+// bytecodeFormat: >=EOFv1
+// ----
+// Assembly:
+//     /* "source":22:29   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+//
+// sub_0: assembly {
+//         /* "source":123:124   */
+//       0x01
+//         /* "source":120:121   */
+//       0x00
+//         /* "source":113:125   */
+//       sstore
+//         /* "source":109:129   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":187:188   */
+//           0x03
+//             /* "source":184:185   */
+//           0x02
+//             /* "source":177:189   */
+//           sstore
+//             /* "source":173:193   */
+//           stop
+//         stop
+//         data_6adf031833174bbe4c85eafe59ddb54e6584648c2c962c6f94791ab49caa0ad4 123456
+//     }
+// }
+// Bytecode: ef0001010004020001000104000d00008000000048656c6c6f2c20576f726c6421
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP ADD DIV STOP 0xD STOP STOP DUP1 STOP STOP STOP BASEFEE PUSH6 0x6C6C6F2C2057 PUSH16 0x726C6421000000000000000000000000
+// SourceMappings: 22:7:0:-:0
diff --git a/test/libyul/objectCompiler/eof/verbatim_bug.yul b/test/libyul/objectCompiler/eof/verbatim_bug.yul
new file mode 100644
index 000000000000..99b2bc19dd4c
--- /dev/null
+++ b/test/libyul/objectCompiler/eof/verbatim_bug.yul
@@ -0,0 +1,120 @@
+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)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// bytecodeFormat: >=EOFv1
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":65:66   */
+//   0x00
+//     /* "source":59:67   */
+//   sload
+//     /* "source":94:95   */
+//   0x00
+//     /* "source":108:406   */
+//   swap1
+//     /* "source":133:225   */
+//   dup1
+//     /* "source":138:142   */
+//   0x00
+//     /* "source":133:225   */
+//   eq
+//   rjumpi{tag_1}
+//     /* "source":108:406   */
+// tag_2:
+//     /* "source":238:263   */
+//   dup1
+//     /* "source":243:247   */
+//   0x01
+//     /* "source":238:263   */
+//   eq
+//   rjumpi{tag_3}
+//     /* "source":108:406   */
+// tag_4:
+//     /* "source":276:368   */
+//   dup1
+//     /* "source":281:285   */
+//   0x02
+//     /* "source":276:368   */
+//   eq
+//   rjumpi{tag_5}
+//     /* "source":108:406   */
+// tag_6:
+//     /* "source":386:390   */
+//   0x03
+//     /* "source":381:406   */
+//   eq
+//   rjumpi{tag_7}
+//     /* "source":108:406   */
+// tag_8:
+//     /* "source":426:427   */
+//   0x00
+//     /* "source":419:436   */
+//   sstore
+//     /* "source":108:406   */
+//   stop
+//     /* "source":391:406   */
+// tag_7:
+//     /* "source":393:404   */
+//   pop
+//     /* "source":403:404   */
+//   0x03
+//     /* "source":391:406   */
+//   rjump{tag_8}
+//     /* "source":286:368   */
+// tag_5:
+//     /* "source":314:354   */
+//   pop
+//   pop
+//     /* "source":339:353   */
+//   0xaabbccddeeff
+//     /* "source":314:354   */
+//   verbatimbytecode_506002
+//     /* "source":286:368   */
+//   rjump{tag_8}
+//     /* "source":248:263   */
+// tag_3:
+//     /* "source":250:261   */
+//   pop
+//   pop
+//     /* "source":260:261   */
+//   0x01
+//     /* "source":248:263   */
+//   rjump{tag_8}
+//     /* "source":143:225   */
+// tag_1:
+//     /* "source":171:211   */
+//   pop
+//   pop
+//     /* "source":196:210   */
+//   0xaabbccddeeff
+//     /* "source":171:211   */
+//   verbatimbytecode_506000
+//     /* "source":143:225   */
+//   rjump{tag_8}
+// Bytecode: ef0001010004020001004c04000000008000045f545f90805f14e1003380600114e1002580600214e1000f600314e100035f5500506003e0fff7505065aabbccddeeff506002e0ffe850506001e0ffe1505065aabbccddeeff506000e0ffd2
+// Opcodes: 0xEF STOP ADD ADD STOP DIV MUL STOP ADD STOP 0x4C DIV STOP STOP STOP STOP DUP1 STOP DIV PUSH0 SLOAD PUSH0 SWAP1 DUP1 PUSH0 EQ RJUMPI 0x33 DUP1 PUSH1 0x1 EQ RJUMPI 0x25 DUP1 PUSH1 0x2 EQ RJUMPI 0xF PUSH1 0x3 EQ RJUMPI 0x3 PUSH0 SSTORE STOP POP PUSH1 0x3 RJUMP 0xFFF7 POP POP PUSH6 0xAABBCCDDEEFF POP PUSH1 0x2 RJUMP 0xFFE8 POP POP PUSH1 0x1 RJUMP 0xFFE1 POP POP PUSH6 0xAABBCCDDEEFF POP PUSH1 0x0 RJUMP 0xFFD2
+// SourceMappings: 65:1:0:-:0;59:8;94:1;108:298;133:92;138:4;133:92;;108:298;238:25;243:4;238:25;;108:298;276:92;281:4;276:92;;108:298;386:4;381:25;;108:298;426:1;419:17;108:298;391:15;393:11;403:1;391:15;286:82;314:40;;339:14;314:40;286:82;248:15;250:11;;260:1;248:15;143:82;171:40;;196:14;171:40;143:82
diff --git a/test/libyul/objectCompiler/function_series.yul b/test/libyul/objectCompiler/function_series.yul
index 8750f164991a..fd5a5d6c05f6 100644
--- a/test/libyul/objectCompiler/function_series.yul
+++ b/test/libyul/objectCompiler/function_series.yul
@@ -13,6 +13,7 @@ object "Contract" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: none
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":33:48   */
diff --git a/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul b/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul
index 01270ef44316..f39352eb0712 100644
--- a/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul
@@ -66,6 +66,7 @@ object "A" {
 // ====
 // EVMVersion: >=constantinople
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //   sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01))
diff --git a/test/libyul/objectCompiler/identical_subobjects_full_debug_info.yul b/test/libyul/objectCompiler/identical_subobjects_full_debug_info.yul
index 88ec2c3542c7..c5f8430b43f6 100644
--- a/test/libyul/objectCompiler/identical_subobjects_full_debug_info.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_full_debug_info.yul
@@ -66,6 +66,7 @@ object "A" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "A.sol":10:20   */
diff --git a/test/libyul/objectCompiler/identical_subobjects_no_debug_info.yul b/test/libyul/objectCompiler/identical_subobjects_no_debug_info.yul
index 309d995469a9..fa383b461a93 100644
--- a/test/libyul/objectCompiler/identical_subobjects_no_debug_info.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_no_debug_info.yul
@@ -52,6 +52,7 @@ object "A" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":83:84   */
diff --git a/test/libyul/objectCompiler/identical_subobjects_partial_debug_info.yul b/test/libyul/objectCompiler/identical_subobjects_partial_debug_info.yul
index 82c2fd766e2c..aac90d8a34e2 100644
--- a/test/libyul/objectCompiler/identical_subobjects_partial_debug_info.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_partial_debug_info.yul
@@ -71,6 +71,7 @@ object "A" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "A.sol":10:20   */
diff --git a/test/libyul/objectCompiler/identical_subobjects_partial_debug_info_no_use_src.yul b/test/libyul/objectCompiler/identical_subobjects_partial_debug_info_no_use_src.yul
index 230535525007..918c42c58acf 100644
--- a/test/libyul/objectCompiler/identical_subobjects_partial_debug_info_no_use_src.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_partial_debug_info_no_use_src.yul
@@ -58,6 +58,7 @@ object "A" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":83:84   */
diff --git a/test/libyul/objectCompiler/identical_subobjects_with_subject_references.yul b/test/libyul/objectCompiler/identical_subobjects_with_subject_references.yul
index 74f613cdfffa..2cc8269418f5 100644
--- a/test/libyul/objectCompiler/identical_subobjects_with_subject_references.yul
+++ b/test/libyul/objectCompiler/identical_subobjects_with_subject_references.yul
@@ -97,6 +97,7 @@ object "A" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //   sstore(calldataload(0x00), calldataload(dataOffset(sub_0)))
diff --git a/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul b/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul
index 18d31087f9c5..e77506c30fbd 100644
--- a/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul
+++ b/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul
@@ -9,6 +9,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":143:185   */
diff --git a/test/libyul/objectCompiler/jump_tags.yul b/test/libyul/objectCompiler/jump_tags.yul
index 0d1f1ff791ab..9261c7765653 100644
--- a/test/libyul/objectCompiler/jump_tags.yul
+++ b/test/libyul/objectCompiler/jump_tags.yul
@@ -12,6 +12,7 @@ object "Contract" {
 
 // ====
 // optimizationPreset: none
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":33:54   */
diff --git a/test/libyul/objectCompiler/leading_and_trailing_dots.yul b/test/libyul/objectCompiler/leading_and_trailing_dots.yul
index ddacd8b45dde..7229535ac5f5 100644
--- a/test/libyul/objectCompiler/leading_and_trailing_dots.yul
+++ b/test/libyul/objectCompiler/leading_and_trailing_dots.yul
@@ -14,6 +14,7 @@
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":53:54   */
diff --git a/test/libyul/objectCompiler/linkersymbol.yul b/test/libyul/objectCompiler/linkersymbol.yul
index ba0319108b27..d5f66d544dca 100644
--- a/test/libyul/objectCompiler/linkersymbol.yul
+++ b/test/libyul/objectCompiler/linkersymbol.yul
@@ -7,6 +7,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":190:191   */
diff --git a/test/libyul/objectCompiler/long_object_name.yul b/test/libyul/objectCompiler/long_object_name.yul
index 805beb42495d..b1993bb8cb32 100644
--- a/test/libyul/objectCompiler/long_object_name.yul
+++ b/test/libyul/objectCompiler/long_object_name.yul
@@ -9,6 +9,7 @@ object "t" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":56:169   */
diff --git a/test/libyul/objectCompiler/manySubObjects.yul b/test/libyul/objectCompiler/manySubObjects.yul
index 1a087f9c9430..a0f364a181af 100644
--- a/test/libyul/objectCompiler/manySubObjects.yul
+++ b/test/libyul/objectCompiler/manySubObjects.yul
@@ -136,6 +136,7 @@ object "root" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":59:75   */
diff --git a/test/libyul/objectCompiler/metadata.yul b/test/libyul/objectCompiler/metadata.yul
index dbd802e3384d..3787710e644c 100644
--- a/test/libyul/objectCompiler/metadata.yul
+++ b/test/libyul/objectCompiler/metadata.yul
@@ -21,6 +21,7 @@ object "A" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":55:68   */
diff --git a/test/libyul/objectCompiler/namedObject.yul b/test/libyul/objectCompiler/namedObject.yul
index 66727585dbcb..1897414b1e90 100644
--- a/test/libyul/objectCompiler/namedObject.yul
+++ b/test/libyul/objectCompiler/namedObject.yul
@@ -3,6 +3,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":22:29   */
diff --git a/test/libyul/objectCompiler/namedObjectCode.yul b/test/libyul/objectCompiler/namedObjectCode.yul
index efb41524b5cc..d66138c18f33 100644
--- a/test/libyul/objectCompiler/namedObjectCode.yul
+++ b/test/libyul/objectCompiler/namedObjectCode.yul
@@ -3,6 +3,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":36:37   */
diff --git a/test/libyul/objectCompiler/nested_optimizer.yul b/test/libyul/objectCompiler/nested_optimizer.yul
index 0275e1665ae5..2833f58597e1 100644
--- a/test/libyul/objectCompiler/nested_optimizer.yul
+++ b/test/libyul/objectCompiler/nested_optimizer.yul
@@ -17,6 +17,7 @@ object "a" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":58:59   */
diff --git a/test/libyul/objectCompiler/simple.yul b/test/libyul/objectCompiler/simple.yul
index f7f945abf58a..3af2c0f6a05d 100644
--- a/test/libyul/objectCompiler/simple.yul
+++ b/test/libyul/objectCompiler/simple.yul
@@ -3,6 +3,7 @@
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":41:42   */
diff --git a/test/libyul/objectCompiler/simple_optimizer.yul b/test/libyul/objectCompiler/simple_optimizer.yul
index 7348b2e20cd4..a24386cf4de2 100644
--- a/test/libyul/objectCompiler/simple_optimizer.yul
+++ b/test/libyul/objectCompiler/simple_optimizer.yul
@@ -7,6 +7,7 @@
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":63:64   */
diff --git a/test/libyul/objectCompiler/smoke.yul b/test/libyul/objectCompiler/smoke.yul
index 2ca3d62f004a..06736baa8710 100644
--- a/test/libyul/objectCompiler/smoke.yul
+++ b/test/libyul/objectCompiler/smoke.yul
@@ -2,6 +2,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":27:34   */
diff --git a/test/libyul/objectCompiler/sourceLocations.yul b/test/libyul/objectCompiler/sourceLocations.yul
index a1e55ade4ae1..756260259b2c 100644
--- a/test/libyul/objectCompiler/sourceLocations.yul
+++ b/test/libyul/objectCompiler/sourceLocations.yul
@@ -30,6 +30,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "abc.sol":0:2   */
diff --git a/test/libyul/objectCompiler/subObject.yul b/test/libyul/objectCompiler/subObject.yul
index f394054d74f0..c10cbaac1407 100644
--- a/test/libyul/objectCompiler/subObject.yul
+++ b/test/libyul/objectCompiler/subObject.yul
@@ -6,6 +6,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":22:29   */
diff --git a/test/libyul/objectCompiler/subObjectAccess.yul b/test/libyul/objectCompiler/subObjectAccess.yul
index 047eae408730..1ef30838f9a8 100644
--- a/test/libyul/objectCompiler/subObjectAccess.yul
+++ b/test/libyul/objectCompiler/subObjectAccess.yul
@@ -67,6 +67,7 @@ object "A" {
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":57:72   */
diff --git a/test/libyul/objectCompiler/subSubObject.yul b/test/libyul/objectCompiler/subSubObject.yul
index a7274ce639db..2aa89592be5a 100644
--- a/test/libyul/objectCompiler/subSubObject.yul
+++ b/test/libyul/objectCompiler/subSubObject.yul
@@ -12,6 +12,7 @@ object "a" {
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":22:29   */
diff --git a/test/libyul/objectCompiler/verbatim_bug.yul b/test/libyul/objectCompiler/verbatim_bug.yul
index 3858b5984dba..547869b041ed 100644
--- a/test/libyul/objectCompiler/verbatim_bug.yul
+++ b/test/libyul/objectCompiler/verbatim_bug.yul
@@ -25,6 +25,7 @@ object "a" {
 // ====
 // EVMVersion: >=shanghai
 // optimizationPreset: full
+// bytecodeFormat: legacy
 // ----
 // Assembly:
 //     /* "source":65:66   */
diff --git a/test/libyul/yulControlFlowGraph/ambiguous_names.yul b/test/libyul/yulControlFlowGraph/ambiguous_names.yul
index fabeda45b80f..e7aaeadbba3d 100644
--- a/test/libyul/yulControlFlowGraph/ambiguous_names.yul
+++ b/test/libyul/yulControlFlowGraph/ambiguous_names.yul
@@ -14,6 +14,8 @@
     function b() {}
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulControlFlowGraph/complex.yul b/test/libyul/yulControlFlowGraph/complex.yul
index 4001a93092e1..718ea6770979 100644
--- a/test/libyul/yulControlFlowGraph/complex.yul
+++ b/test/libyul/yulControlFlowGraph/complex.yul
@@ -43,6 +43,8 @@
     }
     pop(f(1,2))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulControlFlowGraph/function.yul b/test/libyul/yulControlFlowGraph/function.yul
index f65c7505cb9d..0e3691a426cd 100644
--- a/test/libyul/yulControlFlowGraph/function.yul
+++ b/test/libyul/yulControlFlowGraph/function.yul
@@ -18,6 +18,8 @@
     h(x)
     h(y)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulControlFlowGraph/leave.yul b/test/libyul/yulControlFlowGraph/leave.yul
index 4d0a63af4805..d6f475513b4d 100644
--- a/test/libyul/yulControlFlowGraph/leave.yul
+++ b/test/libyul/yulControlFlowGraph/leave.yul
@@ -11,6 +11,8 @@
 
     pop(f(0,1))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulInterpreterTests/and_create.yul b/test/libyul/yulInterpreterTests/and_create.yul
index da962c3c0b04..5d8cd6cfde8d 100644
--- a/test/libyul/yulInterpreterTests/and_create.yul
+++ b/test/libyul/yulInterpreterTests/and_create.yul
@@ -4,6 +4,8 @@
     let b := and(u160max, create(0, u160max, 0))
     mstore(0, eq(a, b))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CREATE(0, 0, 0)
diff --git a/test/libyul/yulInterpreterTests/and_create2.yul b/test/libyul/yulInterpreterTests/and_create2.yul
index 0b83d818f087..c076c1203e11 100644
--- a/test/libyul/yulInterpreterTests/and_create2.yul
+++ b/test/libyul/yulInterpreterTests/and_create2.yul
@@ -6,6 +6,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CREATE2(0, 0, 0, 0)
diff --git a/test/libyul/yulInterpreterTests/create2.yul b/test/libyul/yulInterpreterTests/create2.yul
index b7484f5db8de..ad6eb5383796 100644
--- a/test/libyul/yulInterpreterTests/create2.yul
+++ b/test/libyul/yulInterpreterTests/create2.yul
@@ -5,6 +5,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CREATE2(0, 0, 32, 32)
diff --git a/test/libyul/yulInterpreterTests/datacopy.yul b/test/libyul/yulInterpreterTests/datacopy.yul
index ce5b6ce5c53a..61a3259a7c96 100644
--- a/test/libyul/yulInterpreterTests/datacopy.yul
+++ b/test/libyul/yulInterpreterTests/datacopy.yul
@@ -8,6 +8,8 @@ object "main"
     }
     object "sub" { code { sstore(0, 1) } }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 // Memory dump:
diff --git a/test/libyul/yulInterpreterTests/dataoffset.yul b/test/libyul/yulInterpreterTests/dataoffset.yul
index f5a9aeb12f34..366ceb4bd273 100644
--- a/test/libyul/yulInterpreterTests/dataoffset.yul
+++ b/test/libyul/yulInterpreterTests/dataoffset.yul
@@ -6,6 +6,8 @@ object "main"
     }
     object "sub" { code { sstore(0, 1) } }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 // Memory dump:
diff --git a/test/libyul/yulInterpreterTests/datasize.yul b/test/libyul/yulInterpreterTests/datasize.yul
index ff80edee7c94..f03d7083699f 100644
--- a/test/libyul/yulInterpreterTests/datasize.yul
+++ b/test/libyul/yulInterpreterTests/datasize.yul
@@ -6,6 +6,8 @@ object "main"
     }
     object "sub" { code { sstore(0, 1) } }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 // Memory dump:
diff --git a/test/libyul/yulInterpreterTests/external_call_to_self.yul b/test/libyul/yulInterpreterTests/external_call_to_self.yul
index 3f5c887b4aeb..b2d69086a54f 100644
--- a/test/libyul/yulInterpreterTests/external_call_to_self.yul
+++ b/test/libyul/yulInterpreterTests/external_call_to_self.yul
@@ -11,6 +11,7 @@
 }
 // ====
 // simulateExternalCall: true
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CALL(153, 0x11111111, 0, 64, 32, 256, 32)
diff --git a/test/libyul/yulInterpreterTests/external_call_unexecuted.yul b/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
index 0a5458b47e2f..93bb9ec03d7b 100644
--- a/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
+++ b/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
@@ -2,6 +2,8 @@
 	let x := call(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
 	sstore(0x64, x)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CALL(153, 69, 5, 0, 32, 48, 32)
diff --git a/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul b/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
index 5245d7443a93..5d0da5c0633e 100644
--- a/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
+++ b/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
@@ -2,6 +2,8 @@
 	let x := callcode(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
 	sstore(100, x)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CALLCODE(153, 69, 5, 0, 32, 48, 32)
diff --git a/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul b/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
index a827181fca2c..3e84df570931 100644
--- a/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
+++ b/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
@@ -2,6 +2,8 @@
 	let x := delegatecall(gas(), 0x45, 0, 0x20, 0x30, 0x20)
 	sstore(100, x)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   DELEGATECALL(153, 69, 0, 32, 48, 32)
diff --git a/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul b/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
index 66ea146a06ab..664692bad565 100644
--- a/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
+++ b/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
@@ -4,6 +4,7 @@
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   STATICCALL(153, 69, 0, 32, 48, 32)
diff --git a/test/libyul/yulInterpreterTests/long_obect_name.yul b/test/libyul/yulInterpreterTests/long_obect_name.yul
index ede304029997..69b7acbb2bf9 100644
--- a/test/libyul/yulInterpreterTests/long_obect_name.yul
+++ b/test/libyul/yulInterpreterTests/long_obect_name.yul
@@ -13,6 +13,8 @@ object "t" {
 		}
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // Trace:
 // Memory dump:
diff --git a/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul b/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul
index ec9ca2fe6437..4386711a1c26 100644
--- a/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul
+++ b/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul
@@ -3,6 +3,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   CALL(0, 0, 0, 0, 0, 0, 0)
diff --git a/test/libyul/yulInterpreterTests/side_effect_free.yul b/test/libyul/yulInterpreterTests/side_effect_free.yul
index adedd299f579..d68d57364b2b 100644
--- a/test/libyul/yulInterpreterTests/side_effect_free.yul
+++ b/test/libyul/yulInterpreterTests/side_effect_free.yul
@@ -14,6 +14,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 // Memory dump:
diff --git a/test/libyul/yulInterpreterTests/zero_length_reads.yul b/test/libyul/yulInterpreterTests/zero_length_reads.yul
index 661db49ffbb6..68cae1b92129 100644
--- a/test/libyul/yulInterpreterTests/zero_length_reads.yul
+++ b/test/libyul/yulInterpreterTests/zero_length_reads.yul
@@ -18,6 +18,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   RETURNDATACOPY(0, 1, 0)
diff --git a/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul b/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul
index 0d0f92420e30..c9143d7918f5 100644
--- a/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul
+++ b/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul
@@ -18,6 +18,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // Trace:
 //   RETURNDATACOPY(0, 1, 0)
diff --git a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_for.yul b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_for.yul
index ac4ed1b0545e..e28d60ece41f 100644
--- a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_for.yul
+++ b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_for.yul
@@ -6,6 +6,8 @@
 	}
 	mstore(1, codesize())
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: commonSubexpressionEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/long_literals_as_builtin_args.yul b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/long_literals_as_builtin_args.yul
index f480bec9e1ae..e4ad176e846f 100644
--- a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/long_literals_as_builtin_args.yul
+++ b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/long_literals_as_builtin_args.yul
@@ -10,6 +10,8 @@ object "AccessControlDefaultAdminRules4233_14" {
     data "AccessControlDefaultAdminRules4233_14_deployed" "AccessControlDefaultAdminRules4233_14_deployed"
 
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: commonSubexpressionEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr2.yul b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr2.yul
index ed8916e63723..210b697f46a4 100644
--- a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr2.yul
+++ b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr2.yul
@@ -2,6 +2,8 @@
     let a := gas()
     let b := gas()
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: commonSubexpressionEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/object_access.yul b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/object_access.yul
index c8c4e4e1388a..98645c653739 100644
--- a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/object_access.yul
+++ b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/object_access.yul
@@ -14,6 +14,8 @@ object "main" {
     }
     data "abc" "Hello, World!"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: commonSubexpressionEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/trivial.yul b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/trivial.yul
index c64fc93f9833..14855ff5af75 100644
--- a/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/trivial.yul
+++ b/test/libyul/yulOptimizerTests/commonSubexpressionEliminator/trivial.yul
@@ -2,6 +2,8 @@
     let a := mul(1, codesize())
     let b := mul(1, codesize())
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: commonSubexpressionEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/disambiguator/string_as_hex_and_hex_as_string.yul b/test/libyul/yulOptimizerTests/disambiguator/string_as_hex_and_hex_as_string.yul
index f0db2af1b220..e2612756e7a5 100644
--- a/test/libyul/yulOptimizerTests/disambiguator/string_as_hex_and_hex_as_string.yul
+++ b/test/libyul/yulOptimizerTests/disambiguator/string_as_hex_and_hex_as_string.yul
@@ -4,6 +4,8 @@ object "A" {
     }
     data 'abc' "1234"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: disambiguator
 //
diff --git a/test/libyul/yulOptimizerTests/equalStoreEliminator/branching.yul b/test/libyul/yulOptimizerTests/equalStoreEliminator/branching.yul
index 63f0d38e43fe..055c3abe3884 100644
--- a/test/libyul/yulOptimizerTests/equalStoreEliminator/branching.yul
+++ b/test/libyul/yulOptimizerTests/equalStoreEliminator/branching.yul
@@ -11,6 +11,7 @@
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // step: equalStoreEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/equalStoreEliminator/functionbody.yul b/test/libyul/yulOptimizerTests/equalStoreEliminator/functionbody.yul
index 68839721cd76..b6c59eda5448 100644
--- a/test/libyul/yulOptimizerTests/equalStoreEliminator/functionbody.yul
+++ b/test/libyul/yulOptimizerTests/equalStoreEliminator/functionbody.yul
@@ -28,6 +28,7 @@
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // step: equalStoreEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/equalStoreEliminator/verbatim.yul b/test/libyul/yulOptimizerTests/equalStoreEliminator/verbatim.yul
index fcaddd12134d..00b3f03cddce 100644
--- a/test/libyul/yulOptimizerTests/equalStoreEliminator/verbatim.yul
+++ b/test/libyul/yulOptimizerTests/equalStoreEliminator/verbatim.yul
@@ -11,6 +11,7 @@
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // step: equalStoreEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation_datasize.yul b/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation_datasize.yul
index 301f50c6ea27..4d3be77e8239 100644
--- a/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation_datasize.yul
+++ b/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation_datasize.yul
@@ -26,6 +26,8 @@ object "test"
   data 'A' "A"
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: equivalentFunctionCombiner
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul
index a431c57a6c6c..e635ad5d4824 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul
@@ -8,6 +8,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul
index 3710cbebdf48..1f10c90adb7c 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul
@@ -7,6 +7,8 @@
     let b := and(0xffffffffffffffffffffffffffffffffffffffff, create(0, 0, 0x20))
     sstore(a, b)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul
index 19d65dca4152..c73fea65c6e0 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul
@@ -9,6 +9,8 @@
     sstore(9, c)
     sstore(10, d)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul
index abd1b1743d32..d1e00802ffab 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul
@@ -3,6 +3,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul
index 9c3a5c8ba29e..6dc67840697d 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul
@@ -5,6 +5,7 @@
 }
 // ====
 // EVMVersion: >byzantium
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSimplifier/zero_length_read.yul b/test/libyul/yulOptimizerTests/expressionSimplifier/zero_length_read.yul
index ee7464932d3a..7dc84e215dc3 100644
--- a/test/libyul/yulOptimizerTests/expressionSimplifier/zero_length_read.yul
+++ b/test/libyul/yulOptimizerTests/expressionSimplifier/zero_length_read.yul
@@ -5,6 +5,8 @@
 	return(calldataload(3), 0)
 	codecopy(calldataload(4), calldataload(5), sub(42,42))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: expressionSimplifier
 //
diff --git a/test/libyul/yulOptimizerTests/expressionSplitter/object_access.yul b/test/libyul/yulOptimizerTests/expressionSplitter/object_access.yul
index bcd6d0f7bba5..b362f1568c4a 100644
--- a/test/libyul/yulOptimizerTests/expressionSplitter/object_access.yul
+++ b/test/libyul/yulOptimizerTests/expressionSplitter/object_access.yul
@@ -9,6 +9,8 @@ object "main" {
     }
     data "abc" "Hello, World!"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: expressionSplitter
 //
diff --git a/test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul b/test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul
index 0e366e6d4090..af609eb60b61 100644
--- a/test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul
+++ b/test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul
@@ -3,6 +3,8 @@
 	let a := div(create(0, 0, 0), 0)
 	mstore(0, a)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: fullSimplify
 //
diff --git a/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul b/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul
index 38e5ab2108d7..1820f363c52f 100644
--- a/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul
+++ b/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul
@@ -6,6 +6,8 @@
     }
     f(call(2, 0, 1, mod(x, 8), 1, 1, 1))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: fullSimplify
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/aztec.yul b/test/libyul/yulOptimizerTests/fullSuite/aztec.yul
index 8b26a7ba3723..d844a8d924b6 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/aztec.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/aztec.yul
@@ -230,6 +230,7 @@
 }
 // ====
 // EVMVersion: >=istanbul
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul b/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul
index 6ebca20f5bbb..f0c54556a423 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul
@@ -8,6 +8,7 @@
 }
 // ====
 // EVMVersion: >=shanghai
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul b/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul
index 078616bb3b7e..984d9a458d8c 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul
@@ -8,6 +8,7 @@
 }
 // ====
 // EVMVersion: >=istanbul
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul
index dd6cdc0e44c4..772ec67cfec8 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul
@@ -18,6 +18,7 @@
 }
 // ====
 // EVMVersion: >byzantium
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul b/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul
index 5fbe8d22e615..98d984ea284d 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/stack_compressor_msize.yul
@@ -35,6 +35,7 @@
 }
 // ====
 // EVMVersion: >homestead
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul
index 6f82ab27a6d8..2ed57527925a 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner.yul
@@ -14,6 +14,8 @@
         if iszero(out1) { leave }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul
index b066d998bafe..f95e6f30dcc3 100644
--- a/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul
+++ b/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_return.yul
@@ -16,6 +16,8 @@
         if iszero(out1) { leave }
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: fullSuite
 //
diff --git a/test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul b/test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul
index 18c818d15ec6..c67a0f875545 100644
--- a/test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul
+++ b/test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul
@@ -2,6 +2,8 @@
 {
   for {} addmod(keccak256(0x0,create(0x0, 0x0, 0x0)), 0x0, 0x0) {} {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loadResolver
 //
diff --git a/test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul b/test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul
index 840f19005b06..18c657a0704d 100644
--- a/test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul
+++ b/test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul
@@ -14,6 +14,8 @@
 
     function g() {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loadResolver
 //
diff --git a/test/libyul/yulOptimizerTests/loadResolver/staticcall.yul b/test/libyul/yulOptimizerTests/loadResolver/staticcall.yul
index 2a72eee3e215..ede5dc3e8273 100644
--- a/test/libyul/yulOptimizerTests/loadResolver/staticcall.yul
+++ b/test/libyul/yulOptimizerTests/loadResolver/staticcall.yul
@@ -11,6 +11,7 @@
 }
 // ====
 // EVMVersion: >=byzantium
+// bytecodeFormat: legacy
 // ----
 // step: loadResolver
 //
diff --git a/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul b/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul
index 418221a93824..8035d17729bd 100644
--- a/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul
+++ b/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul
@@ -18,6 +18,7 @@
 }
 // ====
 // EVMVersion: >=constantinople
+// bytecodeFormat: legacy
 // ----
 // step: loadResolver
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/complex_move.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/complex_move.yul
index 3c11ca65f0db..d9eb2af691b3 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/complex_move.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/complex_move.yul
@@ -7,6 +7,8 @@
     sstore(a, inv)
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/create_sload.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/create_sload.yul
index 41289503791a..fa6619d05e30 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/create_sload.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/create_sload.yul
@@ -11,6 +11,8 @@
     let z := f()
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_state_function.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_state_function.yul
index 1d1a1491558f..89f06fdfc929 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_state_function.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/move_state_function.yul
@@ -8,6 +8,8 @@
     let q := g()
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_immovables.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_immovables.yul
index 8881fdc84887..8dcf8ae33763 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_immovables.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_immovables.yul
@@ -9,6 +9,8 @@
     let e := sload(g())
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory.yul
index 942a3c5802cb..ccc62084ee05 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory.yul
@@ -14,6 +14,8 @@
     mstore(a, inv)
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_msize.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_msize.yul
index 2033a9be91a4..96e37e4d0bd5 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_msize.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_memory_msize.yul
@@ -12,6 +12,8 @@
     a := add(x, 1)
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state.yul
index fa6c985b4f8a..c2ea86bc82f0 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state.yul
@@ -25,6 +25,8 @@
   }
 
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_function.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_function.yul
index d3dce8d781b6..609cbe130d4b 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_function.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_function.yul
@@ -11,6 +11,8 @@
     let q := sload(g())
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_loop.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_loop.yul
index 8de9147d8aed..1efa4f7da5f7 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_loop.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_loop.yul
@@ -8,6 +8,8 @@
     let q := g()
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_recursive_function.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_recursive_function.yul
index 1eb0ccd6dd96..02cc64c29742 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_recursive_function.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_state_recursive_function.yul
@@ -8,6 +8,8 @@
     let q := sload(g())
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_staticall_returndatasize.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_staticall_returndatasize.yul
index ae20f4904f88..a5f2125a0300 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_staticall_returndatasize.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_staticall_returndatasize.yul
@@ -10,6 +10,8 @@
   }
 }
 // ====
+// bytecodeFormat: legacy
+// ====
 // EVMVersion: >=byzantium
 // ----
 // step: loopInvariantCodeMotion
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage.yul
index 0ef2fd78ad40..2d8e642dbeb6 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_storage.yul
@@ -25,6 +25,8 @@
   }
 
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_state.yul b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_state.yul
index f8b5a3d53725..23809db6f223 100644
--- a/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_state.yul
+++ b/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/simple_state.yul
@@ -7,6 +7,8 @@
     mstore(a, inv)
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: loopInvariantCodeMotion
 //
diff --git a/test/libyul/yulOptimizerTests/rematerialiser/reassign.yul b/test/libyul/yulOptimizerTests/rematerialiser/reassign.yul
index ef6e12ab6ec2..ab1ad58eeb4d 100644
--- a/test/libyul/yulOptimizerTests/rematerialiser/reassign.yul
+++ b/test/libyul/yulOptimizerTests/rematerialiser/reassign.yul
@@ -6,6 +6,8 @@
     let d := add(b, c)
     pop(a) pop(b) pop(c) pop(d)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: rematerialiser
 //
diff --git a/test/libyul/yulOptimizerTests/rematerialiser/update_asignment_remat.yul b/test/libyul/yulOptimizerTests/rematerialiser/update_asignment_remat.yul
index bb5f029803fa..973998db88eb 100644
--- a/test/libyul/yulOptimizerTests/rematerialiser/update_asignment_remat.yul
+++ b/test/libyul/yulOptimizerTests/rematerialiser/update_asignment_remat.yul
@@ -4,6 +4,8 @@
 	a := mul(a, 2)
 	let b := a
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: rematerialiser
 //
diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/call_does_not_need_to_write.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/call_does_not_need_to_write.yul
index eeff779f85e0..2a65462e86bf 100644
--- a/test/libyul/yulOptimizerTests/unusedStoreEliminator/call_does_not_need_to_write.yul
+++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/call_does_not_need_to_write.yul
@@ -12,6 +12,8 @@
   sstore(0, mload(0))
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: unusedStoreEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul
index c3183d9ec83b..dc339466f864 100644
--- a/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul
+++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create.yul
@@ -4,6 +4,8 @@
     pop(create(0, 0, 0))
     sstore(x, 20)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: unusedStoreEliminator
 //
diff --git a/test/libyul/yulOptimizerTests/unusedStoreEliminator/create_inside_function.yul b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create_inside_function.yul
index 782c68663b08..788e7be21ddd 100644
--- a/test/libyul/yulOptimizerTests/unusedStoreEliminator/create_inside_function.yul
+++ b/test/libyul/yulOptimizerTests/unusedStoreEliminator/create_inside_function.yul
@@ -7,6 +7,8 @@
     f()
     sstore(x, 20)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // step: unusedStoreEliminator
 //
diff --git a/test/libyul/yulStackLayout/complex.yul b/test/libyul/yulStackLayout/complex.yul
index 604dca1f46e2..66390f7d4741 100644
--- a/test/libyul/yulStackLayout/complex.yul
+++ b/test/libyul/yulStackLayout/complex.yul
@@ -48,6 +48,8 @@
     }
     pop(f(1,2))
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulStackLayout/function.yul b/test/libyul/yulStackLayout/function.yul
index e01a8dcb3610..9c50a7b37de7 100644
--- a/test/libyul/yulStackLayout/function.yul
+++ b/test/libyul/yulStackLayout/function.yul
@@ -20,6 +20,8 @@
     // This calla of g() is unreachable too as the one in h() but we wanna cover both cases.
     g()
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulStackLayout/literal_loop.yul b/test/libyul/yulStackLayout/literal_loop.yul
index 841c4106262d..fee5f7b5673a 100644
--- a/test/libyul/yulStackLayout/literal_loop.yul
+++ b/test/libyul/yulStackLayout/literal_loop.yul
@@ -4,6 +4,8 @@
 			{}
 			{}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // digraph CFG {
 // nodesep=0.7;
diff --git a/test/libyul/yulSyntaxTests/builtin_function_literal.yul b/test/libyul/yulSyntaxTests/builtin_function_literal.yul
index 22f7216146a6..c975648ae2df 100644
--- a/test/libyul/yulSyntaxTests/builtin_function_literal.yul
+++ b/test/libyul/yulSyntaxTests/builtin_function_literal.yul
@@ -1,6 +1,8 @@
 {
   datasize(x,1)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 7000: (4-12): Function "datasize" expects 1 arguments but got 2.
 // TypeError 9114: (4-12): Function expects direct literals as arguments.
diff --git a/test/libyul/yulSyntaxTests/datacopy_shadowing.yul b/test/libyul/yulSyntaxTests/datacopy_shadowing.yul
index 3f14f47226a9..7466af6c3863 100644
--- a/test/libyul/yulSyntaxTests/datacopy_shadowing.yul
+++ b/test/libyul/yulSyntaxTests/datacopy_shadowing.yul
@@ -1,5 +1,7 @@
 {
     function datacopy(a, b, c) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (15-23): Cannot use builtin function name "datacopy" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/dataoffset_shadowing.yul b/test/libyul/yulSyntaxTests/dataoffset_shadowing.yul
index fb32fb61c17a..db02e90e4881 100644
--- a/test/libyul/yulSyntaxTests/dataoffset_shadowing.yul
+++ b/test/libyul/yulSyntaxTests/dataoffset_shadowing.yul
@@ -1,5 +1,7 @@
 {
     function dataoffset(a) -> b {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (15-25): Cannot use builtin function name "dataoffset" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/datasize_shadowing.yul b/test/libyul/yulSyntaxTests/datasize_shadowing.yul
index 379401754cac..79e500949e8b 100644
--- a/test/libyul/yulSyntaxTests/datasize_shadowing.yul
+++ b/test/libyul/yulSyntaxTests/datasize_shadowing.yul
@@ -1,5 +1,7 @@
 {
     function datasize(a) -> b {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (15-23): Cannot use builtin function name "datasize" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/hex_switch_case.yul b/test/libyul/yulSyntaxTests/hex_switch_case.yul
index e0d00539a4a8..f0d8f51fc89b 100644
--- a/test/libyul/yulSyntaxTests/hex_switch_case.yul
+++ b/test/libyul/yulSyntaxTests/hex_switch_case.yul
@@ -3,4 +3,6 @@
     case hex"00" {}
     case hex"1122" {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/hex_switch_case_long.yul b/test/libyul/yulSyntaxTests/hex_switch_case_long.yul
index abdbc6ec15f6..854230aa9781 100644
--- a/test/libyul/yulSyntaxTests/hex_switch_case_long.yul
+++ b/test/libyul/yulSyntaxTests/hex_switch_case_long.yul
@@ -3,5 +3,7 @@
     case hex"00" {}
     case hex"112233445566778899001122334455667788990011223344556677889900112233445566778899001122334455667788990011223344556677889900" {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3069: (53-178): String literal too long (60 > 32)
diff --git a/test/libyul/yulSyntaxTests/invalid/pc_disallowed.yul b/test/libyul/yulSyntaxTests/invalid/pc_disallowed.yul
index d5b3847b1743..6a5587c972ae 100644
--- a/test/libyul/yulSyntaxTests/invalid/pc_disallowed.yul
+++ b/test/libyul/yulSyntaxTests/invalid/pc_disallowed.yul
@@ -1,5 +1,7 @@
 {
     pop(pc())
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // SyntaxError 2450: (10-12): PC instruction is a low-level EVM feature. Because of that PC is disallowed in strict assembly.
diff --git a/test/libyul/yulSyntaxTests/loadimmutable.yul b/test/libyul/yulSyntaxTests/loadimmutable.yul
index 6aea058b5d57..7c40a65034d5 100644
--- a/test/libyul/yulSyntaxTests/loadimmutable.yul
+++ b/test/libyul/yulSyntaxTests/loadimmutable.yul
@@ -3,4 +3,5 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/loadimmutable_bad_literal.yul b/test/libyul/yulSyntaxTests/loadimmutable_bad_literal.yul
index 2aadd2f208f0..ea1d7186f29f 100644
--- a/test/libyul/yulSyntaxTests/loadimmutable_bad_literal.yul
+++ b/test/libyul/yulSyntaxTests/loadimmutable_bad_literal.yul
@@ -5,6 +5,7 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
 // TypeError 5859: (24-25): Function expects string literal.
 // TypeError 5859: (50-54): Function expects string literal.
diff --git a/test/libyul/yulSyntaxTests/loadimmutable_shadowing.yul b/test/libyul/yulSyntaxTests/loadimmutable_shadowing.yul
index 8711d0b17757..8156bd4fba49 100644
--- a/test/libyul/yulSyntaxTests/loadimmutable_shadowing.yul
+++ b/test/libyul/yulSyntaxTests/loadimmutable_shadowing.yul
@@ -3,5 +3,6 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (15-28): Cannot use builtin function name "loadimmutable" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/metadata_access.yul b/test/libyul/yulSyntaxTests/metadata_access.yul
index 63aeb4760296..52bf786cda73 100644
--- a/test/libyul/yulSyntaxTests/metadata_access.yul
+++ b/test/libyul/yulSyntaxTests/metadata_access.yul
@@ -21,6 +21,8 @@ object "A" {
   data ".metadata" "Hello, World!"
   data ".other" "Hello, World2!"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3517: (41-49): Unknown data object ".other".
 // TypeError 3517: (69-77): Unknown data object ".other".
diff --git a/test/libyul/yulSyntaxTests/metadata_access_2.yul b/test/libyul/yulSyntaxTests/metadata_access_2.yul
index a4b013e854ff..204409d3e97f 100644
--- a/test/libyul/yulSyntaxTests/metadata_access_2.yul
+++ b/test/libyul/yulSyntaxTests/metadata_access_2.yul
@@ -9,5 +9,7 @@ object "A" {
   data "1" "XYZ"
   data ".mightbereservedinthefuture" "TRS"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3517: (90-119): Unknown data object ".mightbereservedinthefuture".
diff --git a/test/libyul/yulSyntaxTests/metadata_access_subobject.yul b/test/libyul/yulSyntaxTests/metadata_access_subobject.yul
index 216b56ac649c..c52ab9e1a66c 100644
--- a/test/libyul/yulSyntaxTests/metadata_access_subobject.yul
+++ b/test/libyul/yulSyntaxTests/metadata_access_subobject.yul
@@ -8,5 +8,7 @@ object "A" {
 		data "x" "ABC"
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3517: (41-54): Unknown data object ".metadata.x".
diff --git a/test/libyul/yulSyntaxTests/objects/data.yul b/test/libyul/yulSyntaxTests/objects/data.yul
index 47d7b59c7f0a..744a88c64578 100644
--- a/test/libyul/yulSyntaxTests/objects/data.yul
+++ b/test/libyul/yulSyntaxTests/objects/data.yul
@@ -6,4 +6,6 @@ object "A" {
   data "2" hex"0011"
   data "3" "hello world this is longer than 32 bytes and should still work"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/objects/data_access.yul b/test/libyul/yulSyntaxTests/objects/data_access.yul
index e9455fafab33..681cb5028056 100644
--- a/test/libyul/yulSyntaxTests/objects/data_access.yul
+++ b/test/libyul/yulSyntaxTests/objects/data_access.yul
@@ -6,4 +6,6 @@ object "A" {
 
   data "B" hex"00"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/objects/datacopy.yul b/test/libyul/yulSyntaxTests/objects/datacopy.yul
index 6e36025fcbd1..1afb88e2739b 100644
--- a/test/libyul/yulSyntaxTests/objects/datacopy.yul
+++ b/test/libyul/yulSyntaxTests/objects/datacopy.yul
@@ -6,4 +6,6 @@
     let s := ""
     datacopy(x, "11", s)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/objects/dataoffset_nonliteral.yul b/test/libyul/yulSyntaxTests/objects/dataoffset_nonliteral.yul
index d53e26281eae..ba80b462efd0 100644
--- a/test/libyul/yulSyntaxTests/objects/dataoffset_nonliteral.yul
+++ b/test/libyul/yulSyntaxTests/objects/dataoffset_nonliteral.yul
@@ -6,5 +6,7 @@ object "A" {
 
   data "B" hex"00"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 9114: (47-57): Function expects direct literals as arguments.
diff --git a/test/libyul/yulSyntaxTests/objects/dataoffset_nonstring.yul b/test/libyul/yulSyntaxTests/objects/dataoffset_nonstring.yul
index 93a981d924e0..1ac18c19c5bb 100644
--- a/test/libyul/yulSyntaxTests/objects/dataoffset_nonstring.yul
+++ b/test/libyul/yulSyntaxTests/objects/dataoffset_nonstring.yul
@@ -3,5 +3,7 @@ object "A" {
     pop(dataoffset(0))
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 5859: (41-42): Function expects string literal.
diff --git a/test/libyul/yulSyntaxTests/objects/dataoffset_notfound.yul b/test/libyul/yulSyntaxTests/objects/dataoffset_notfound.yul
index 14df40201418..3ee03d66e63d 100644
--- a/test/libyul/yulSyntaxTests/objects/dataoffset_notfound.yul
+++ b/test/libyul/yulSyntaxTests/objects/dataoffset_notfound.yul
@@ -4,5 +4,7 @@ object "A" {
   }
   data "B" ""
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3517: (41-44): Unknown data object "C".
diff --git a/test/libyul/yulSyntaxTests/objects/datasize_nonliteral.yul b/test/libyul/yulSyntaxTests/objects/datasize_nonliteral.yul
index 837408b9a00b..a5179f3e45e2 100644
--- a/test/libyul/yulSyntaxTests/objects/datasize_nonliteral.yul
+++ b/test/libyul/yulSyntaxTests/objects/datasize_nonliteral.yul
@@ -6,5 +6,7 @@ object "A" {
 
   data "B" hex"00"
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 9114: (47-55): Function expects direct literals as arguments.
diff --git a/test/libyul/yulSyntaxTests/objects/datasize_nonstring.yul b/test/libyul/yulSyntaxTests/objects/datasize_nonstring.yul
index 19042a2df738..c8697d06b3dc 100644
--- a/test/libyul/yulSyntaxTests/objects/datasize_nonstring.yul
+++ b/test/libyul/yulSyntaxTests/objects/datasize_nonstring.yul
@@ -3,5 +3,7 @@ object "A" {
     pop(datasize(0))
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 5859: (39-40): Function expects string literal.
diff --git a/test/libyul/yulSyntaxTests/objects/datasize_notfound.yul b/test/libyul/yulSyntaxTests/objects/datasize_notfound.yul
index 48a2c268e205..4fe607a0b8da 100644
--- a/test/libyul/yulSyntaxTests/objects/datasize_notfound.yul
+++ b/test/libyul/yulSyntaxTests/objects/datasize_notfound.yul
@@ -4,5 +4,7 @@ object "A" {
   }
   data "B" ""
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // TypeError 3517: (39-42): Unknown data object "C".
diff --git a/test/libyul/yulSyntaxTests/objects/subobject_access.yul b/test/libyul/yulSyntaxTests/objects/subobject_access.yul
index 59426a0aa631..11fd37d9c6f0 100644
--- a/test/libyul/yulSyntaxTests/objects/subobject_access.yul
+++ b/test/libyul/yulSyntaxTests/objects/subobject_access.yul
@@ -8,4 +8,6 @@ object "A" {
     code {}
   }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/opcode_for_function_args_1.yul b/test/libyul/yulSyntaxTests/opcode_for_function_args_1.yul
index 00c357bb44aa..2bf6e2c057c5 100644
--- a/test/libyul/yulSyntaxTests/opcode_for_function_args_1.yul
+++ b/test/libyul/yulSyntaxTests/opcode_for_function_args_1.yul
@@ -1,5 +1,7 @@
 {
 	function f(gas) {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (14-17): Cannot use builtin function name "gas" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/opcode_for_function_args_2.yul b/test/libyul/yulSyntaxTests/opcode_for_function_args_2.yul
index 989cfce9e007..3e896e0390f0 100644
--- a/test/libyul/yulSyntaxTests/opcode_for_function_args_2.yul
+++ b/test/libyul/yulSyntaxTests/opcode_for_function_args_2.yul
@@ -1,5 +1,7 @@
 {
 	function f() -> gas {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (19-22): Cannot use builtin function name "gas" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/opcode_for_functions.yul b/test/libyul/yulSyntaxTests/opcode_for_functions.yul
index 0efc7cbccedd..bd16aa090c77 100644
--- a/test/libyul/yulSyntaxTests/opcode_for_functions.yul
+++ b/test/libyul/yulSyntaxTests/opcode_for_functions.yul
@@ -1,5 +1,7 @@
 {
 	function gas() {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (12-15): Cannot use builtin function name "gas" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/passing_builtin_with_literal_argument_into_literal_argument.yul b/test/libyul/yulSyntaxTests/passing_builtin_with_literal_argument_into_literal_argument.yul
index 433d36683dfe..d1e6d50e9e80 100644
--- a/test/libyul/yulSyntaxTests/passing_builtin_with_literal_argument_into_literal_argument.yul
+++ b/test/libyul/yulSyntaxTests/passing_builtin_with_literal_argument_into_literal_argument.yul
@@ -3,5 +3,6 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
 // TypeError 9114: (6-18): Function expects direct literals as arguments.
diff --git a/test/libyul/yulSyntaxTests/selfdestruct.yul b/test/libyul/yulSyntaxTests/selfdestruct.yul
index faecf92c3805..181e9806ddaa 100644
--- a/test/libyul/yulSyntaxTests/selfdestruct.yul
+++ b/test/libyul/yulSyntaxTests/selfdestruct.yul
@@ -1,5 +1,7 @@
 {
 	selfdestruct(0x02)
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // 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/test/libyul/yulSyntaxTests/setimmutable.yul b/test/libyul/yulSyntaxTests/setimmutable.yul
index e1d6a74919c9..88e38b1338a4 100644
--- a/test/libyul/yulSyntaxTests/setimmutable.yul
+++ b/test/libyul/yulSyntaxTests/setimmutable.yul
@@ -3,4 +3,5 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/setimmutable_bad_literal.yul b/test/libyul/yulSyntaxTests/setimmutable_bad_literal.yul
index 9e4bc8032c78..175ab15aa59e 100644
--- a/test/libyul/yulSyntaxTests/setimmutable_bad_literal.yul
+++ b/test/libyul/yulSyntaxTests/setimmutable_bad_literal.yul
@@ -5,6 +5,7 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
 // TypeError 5859: (22-23): Function expects string literal.
 // TypeError 5859: (89-93): Function expects string literal.
diff --git a/test/libyul/yulSyntaxTests/setimmutable_shadowing.yul b/test/libyul/yulSyntaxTests/setimmutable_shadowing.yul
index b76a5de9b729..fbcfeb15ff98 100644
--- a/test/libyul/yulSyntaxTests/setimmutable_shadowing.yul
+++ b/test/libyul/yulSyntaxTests/setimmutable_shadowing.yul
@@ -3,5 +3,6 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----
 // ParserError 5568: (15-27): Cannot use builtin function name "setimmutable" as identifier name.
diff --git a/test/libyul/yulSyntaxTests/string_literal_switch_case.yul b/test/libyul/yulSyntaxTests/string_literal_switch_case.yul
index 6f0d72229947..58e8302c025e 100644
--- a/test/libyul/yulSyntaxTests/string_literal_switch_case.yul
+++ b/test/libyul/yulSyntaxTests/string_literal_switch_case.yul
@@ -3,4 +3,6 @@
     case "1" {}
     case "2" {}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
diff --git a/test/libyul/yulSyntaxTests/string_literal_too_long_immutable.yul b/test/libyul/yulSyntaxTests/string_literal_too_long_immutable.yul
index 98707451e600..d81f69a082ee 100644
--- a/test/libyul/yulSyntaxTests/string_literal_too_long_immutable.yul
+++ b/test/libyul/yulSyntaxTests/string_literal_too_long_immutable.yul
@@ -7,4 +7,5 @@
 }
 // ====
 // dialect: evm
+// bytecodeFormat: legacy
 // ----