diff --git a/scripts/check_style.sh b/scripts/check_style.sh
index 3a268e777..f12fcc8e6 100755
--- a/scripts/check_style.sh
+++ b/scripts/check_style.sh
@@ -34,6 +34,7 @@ NAMESPACE_STD_FREE_FILES=(
     libsolidity/lsp/*
     libsolidity/parsing/*
     libsolutil/*
+    solc/*
 )
 
 (
diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp
index 5fd151159..c729e4591 100644
--- a/solc/CommandLineInterface.cpp
+++ b/solc/CommandLineInterface.cpp
@@ -81,8 +81,7 @@
 	#define STDERR_FILENO 2
 #endif
 
-
-using namespace std;
+using namespace std::string_literals;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::langutil;
@@ -90,7 +89,7 @@ using namespace solidity::langutil;
 namespace
 {
 
-set<frontend::InputMode> const CompilerInputModes{
+std::set<frontend::InputMode> const CompilerInputModes{
 	frontend::InputMode::Compiler,
 	frontend::InputMode::CompilerWithASTImport,
 };
@@ -100,14 +99,14 @@ set<frontend::InputMode> const CompilerInputModes{
 namespace solidity::frontend
 {
 
-ostream& CommandLineInterface::sout(bool _markAsUsed)
+std::ostream& CommandLineInterface::sout(bool _markAsUsed)
 {
 	if (_markAsUsed)
 		m_hasOutput = true;
 	return m_sout;
 }
 
-ostream& CommandLineInterface::serr(bool _markAsUsed)
+std::ostream& CommandLineInterface::serr(bool _markAsUsed)
 {
 	if (_markAsUsed)
 		m_hasOutput = true;
@@ -118,27 +117,27 @@ ostream& CommandLineInterface::serr(bool _markAsUsed)
 #define cout
 #define cerr
 
-static string const g_stdinFileName = "<stdin>";
-static string const g_strAbi = "abi";
-static string const g_strAsm = "asm";
-static string const g_strAst = "ast";
-static string const g_strBinary = "bin";
-static string const g_strBinaryRuntime = "bin-runtime";
-static string const g_strContracts = "contracts";
-static string const g_strFunDebug = "function-debug";
-static string const g_strFunDebugRuntime = "function-debug-runtime";
-static string const g_strGeneratedSources = "generated-sources";
-static string const g_strGeneratedSourcesRuntime = "generated-sources-runtime";
-static string const g_strNatspecDev = "devdoc";
-static string const g_strNatspecUser = "userdoc";
-static string const g_strOpcodes = "opcodes";
-static string const g_strSignatureHashes = "hashes";
-static string const g_strSourceList = "sourceList";
-static string const g_strSources = "sources";
-static string const g_strSrcMap = "srcmap";
-static string const g_strSrcMapRuntime = "srcmap-runtime";
-static string const g_strStorageLayout = "storage-layout";
-static string const g_strVersion = "version";
+static std::string const g_stdinFileName = "<stdin>";
+static std::string const g_strAbi = "abi";
+static std::string const g_strAsm = "asm";
+static std::string const g_strAst = "ast";
+static std::string const g_strBinary = "bin";
+static std::string const g_strBinaryRuntime = "bin-runtime";
+static std::string const g_strContracts = "contracts";
+static std::string const g_strFunDebug = "function-debug";
+static std::string const g_strFunDebugRuntime = "function-debug-runtime";
+static std::string const g_strGeneratedSources = "generated-sources";
+static std::string const g_strGeneratedSourcesRuntime = "generated-sources-runtime";
+static std::string const g_strNatspecDev = "devdoc";
+static std::string const g_strNatspecUser = "userdoc";
+static std::string const g_strOpcodes = "opcodes";
+static std::string const g_strSignatureHashes = "hashes";
+static std::string const g_strSourceList = "sourceList";
+static std::string const g_strSources = "sources";
+static std::string const g_strSrcMap = "srcmap";
+static std::string const g_strSrcMapRuntime = "srcmap-runtime";
+static std::string const g_strStorageLayout = "storage-layout";
+static std::string const g_strVersion = "version";
 
 static bool needsHumanTargetedStdout(CommandLineOptions const& _options)
 {
@@ -167,7 +166,7 @@ static bool coloredOutput(CommandLineOptions const& _options)
 		(_options.formatting.coloredOutput.has_value() && _options.formatting.coloredOutput.value());
 }
 
-void CommandLineInterface::handleBinary(string const& _contract)
+void CommandLineInterface::handleBinary(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -177,8 +176,8 @@ void CommandLineInterface::handleBinary(string const& _contract)
 			createFile(m_compiler->filesystemFriendlyName(_contract) + ".bin", objectWithLinkRefsHex(m_compiler->object(_contract)));
 		else
 		{
-			sout() << "Binary:" << endl;
-			sout() << objectWithLinkRefsHex(m_compiler->object(_contract)) << endl;
+			sout() << "Binary:" << std::endl;
+			sout() << objectWithLinkRefsHex(m_compiler->object(_contract)) << std::endl;
 		}
 	}
 	if (m_options.compiler.outputs.binaryRuntime)
@@ -187,13 +186,13 @@ void CommandLineInterface::handleBinary(string const& _contract)
 			createFile(m_compiler->filesystemFriendlyName(_contract) + ".bin-runtime", objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)));
 		else
 		{
-			sout() << "Binary of the runtime part:" << endl;
-			sout() << objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)) << endl;
+			sout() << "Binary of the runtime part:" << std::endl;
+			sout() << objectWithLinkRefsHex(m_compiler->runtimeObject(_contract)) << std::endl;
 		}
 	}
 }
 
-void CommandLineInterface::handleOpcode(string const& _contract)
+void CommandLineInterface::handleOpcode(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -201,13 +200,13 @@ void CommandLineInterface::handleOpcode(string const& _contract)
 		createFile(m_compiler->filesystemFriendlyName(_contract) + ".opcode", evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion));
 	else
 	{
-		sout() << "Opcodes:" << endl;
-		sout() << uppercase << evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion);
-		sout() << endl;
+		sout() << "Opcodes:" << std::endl;
+		sout() << std::uppercase << evmasm::disassemble(m_compiler->object(_contract).bytecode, m_options.output.evmVersion);
+		sout() << std::endl;
 	}
 }
 
-void CommandLineInterface::handleIR(string const& _contractName)
+void CommandLineInterface::handleIR(std::string const& _contractName)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -218,12 +217,12 @@ void CommandLineInterface::handleIR(string const& _contractName)
 		createFile(m_compiler->filesystemFriendlyName(_contractName) + ".yul", m_compiler->yulIR(_contractName));
 	else
 	{
-		sout() << "IR:" << endl;
-		sout() << m_compiler->yulIR(_contractName) << endl;
+		sout() << "IR:" << std::endl;
+		sout() << m_compiler->yulIR(_contractName) << std::endl;
 	}
 }
 
-void CommandLineInterface::handleIRAst(string const& _contractName)
+void CommandLineInterface::handleIRAst(std::string const& _contractName)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -240,15 +239,15 @@ void CommandLineInterface::handleIRAst(string const& _contractName)
 		);
 	else
 	{
-		sout() << "IR AST:" << endl;
+		sout() << "IR AST:" << std::endl;
 		sout() << util::jsonPrint(
 			m_compiler->yulIRAst(_contractName),
 			m_options.formatting.json
-		) << endl;
+		) << std::endl;
 	}
 }
 
-void CommandLineInterface::handleIROptimized(string const& _contractName)
+void CommandLineInterface::handleIROptimized(std::string const& _contractName)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -262,12 +261,12 @@ void CommandLineInterface::handleIROptimized(string const& _contractName)
 		);
 	else
 	{
-		sout() << "Optimized IR:" << endl;
-		sout() << m_compiler->yulIROptimized(_contractName) << endl;
+		sout() << "Optimized IR:" << std::endl;
+		sout() << m_compiler->yulIROptimized(_contractName) << std::endl;
 	}
 }
 
-void CommandLineInterface::handleIROptimizedAst(string const& _contractName)
+void CommandLineInterface::handleIROptimizedAst(std::string const& _contractName)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -284,15 +283,15 @@ void CommandLineInterface::handleIROptimizedAst(string const& _contractName)
 		);
 	else
 	{
-		sout() << "Optimized IR AST:" << endl;
+		sout() << "Optimized IR AST:" << std::endl;
 		sout() << util::jsonPrint(
 			m_compiler->yulIROptimizedAst(_contractName),
 			m_options.formatting.json
-		) << endl;
+		) << std::endl;
 	}
 }
 
-void CommandLineInterface::handleBytecode(string const& _contract)
+void CommandLineInterface::handleBytecode(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -302,7 +301,7 @@ void CommandLineInterface::handleBytecode(string const& _contract)
 		handleBinary(_contract);
 }
 
-void CommandLineInterface::handleSignatureHashes(string const& _contract)
+void CommandLineInterface::handleSignatureHashes(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
@@ -310,7 +309,7 @@ void CommandLineInterface::handleSignatureHashes(string const& _contract)
 		return;
 
 	Json::Value interfaceSymbols = m_compiler->interfaceSymbols(_contract);
-	string out = "Function signatures:\n";
+	std::string out = "Function signatures:\n";
 	for (auto const& name: interfaceSymbols["methods"].getMemberNames())
 		out += interfaceSymbols["methods"][name].asString() + ": " + name + "\n";
 
@@ -334,55 +333,55 @@ void CommandLineInterface::handleSignatureHashes(string const& _contract)
 		sout() << out;
 }
 
-void CommandLineInterface::handleMetadata(string const& _contract)
+void CommandLineInterface::handleMetadata(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	if (!m_options.compiler.outputs.metadata)
 		return;
 
-	string data = m_compiler->metadata(_contract);
+	std::string data = m_compiler->metadata(_contract);
 	if (!m_options.output.dir.empty())
 		createFile(m_compiler->filesystemFriendlyName(_contract) + "_meta.json", data);
 	else
-		sout() << "Metadata:" << endl << data << endl;
+		sout() << "Metadata:" << std::endl << data << std::endl;
 }
 
-void CommandLineInterface::handleABI(string const& _contract)
+void CommandLineInterface::handleABI(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	if (!m_options.compiler.outputs.abi)
 		return;
 
-	string data = jsonPrint(removeNullMembers(m_compiler->contractABI(_contract)), m_options.formatting.json);
+	std::string data = jsonPrint(removeNullMembers(m_compiler->contractABI(_contract)), m_options.formatting.json);
 	if (!m_options.output.dir.empty())
 		createFile(m_compiler->filesystemFriendlyName(_contract) + ".abi", data);
 	else
-		sout() << "Contract JSON ABI" << endl << data << endl;
+		sout() << "Contract JSON ABI" << std::endl << data << std::endl;
 }
 
-void CommandLineInterface::handleStorageLayout(string const& _contract)
+void CommandLineInterface::handleStorageLayout(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	if (!m_options.compiler.outputs.storageLayout)
 		return;
 
-	string data = jsonPrint(removeNullMembers(m_compiler->storageLayout(_contract)), m_options.formatting.json);
+	std::string data = jsonPrint(removeNullMembers(m_compiler->storageLayout(_contract)), m_options.formatting.json);
 	if (!m_options.output.dir.empty())
 		createFile(m_compiler->filesystemFriendlyName(_contract) + "_storage.json", data);
 	else
-		sout() << "Contract Storage Layout:" << endl << data << endl;
+		sout() << "Contract Storage Layout:" << std::endl << data << std::endl;
 }
 
-void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contract)
+void CommandLineInterface::handleNatspec(bool _natspecDev, std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	bool enabled = false;
-	string suffix;
-	string title;
+	std::string suffix;
+	std::string title;
 
 	if (_natspecDev)
 	{
@@ -399,7 +398,7 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
 
 	if (enabled)
 	{
-		string output = jsonPrint(
+		std::string output = jsonPrint(
 			removeNullMembers(
 				_natspecDev ?
 				m_compiler->natspecDev(_contract) :
@@ -412,51 +411,51 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
 			createFile(m_compiler->filesystemFriendlyName(_contract) + suffix, output);
 		else
 		{
-			sout() << title << endl;
-			sout() << output << endl;
+			sout() << title << std::endl;
+			sout() << output << std::endl;
 		}
 
 	}
 }
 
-void CommandLineInterface::handleGasEstimation(string const& _contract)
+void CommandLineInterface::handleGasEstimation(std::string const& _contract)
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	Json::Value estimates = m_compiler->gasEstimates(_contract);
-	sout() << "Gas estimation:" << endl;
+	sout() << "Gas estimation:" << std::endl;
 
 	if (estimates["creation"].isObject())
 	{
 		Json::Value creation = estimates["creation"];
-		sout() << "construction:" << endl;
+		sout() << "construction:" << std::endl;
 		sout() << "   " << creation["executionCost"].asString();
 		sout() << " + " << creation["codeDepositCost"].asString();
-		sout() << " = " << creation["totalCost"].asString() << endl;
+		sout() << " = " << creation["totalCost"].asString() << std::endl;
 	}
 
 	if (estimates["external"].isObject())
 	{
 		Json::Value externalFunctions = estimates["external"];
-		sout() << "external:" << endl;
+		sout() << "external:" << std::endl;
 		for (auto const& name: externalFunctions.getMemberNames())
 		{
 			if (name.empty())
 				sout() << "   fallback:\t";
 			else
 				sout() << "   " << name << ":\t";
-			sout() << externalFunctions[name].asString() << endl;
+			sout() << externalFunctions[name].asString() << std::endl;
 		}
 	}
 
 	if (estimates["internal"].isObject())
 	{
 		Json::Value internalFunctions = estimates["internal"];
-		sout() << "internal:" << endl;
+		sout() << "internal:" << std::endl;
 		for (auto const& name: internalFunctions.getMemberNames())
 		{
 			sout() << "   " << name << ":\t";
-			sout() << internalFunctions[name].asString() << endl;
+			sout() << internalFunctions[name].asString() << std::endl;
 		}
 	}
 }
@@ -465,7 +464,7 @@ void CommandLineInterface::readInputFiles()
 {
 	solAssert(!m_standardJsonInput.has_value());
 
-	static set<frontend::InputMode> const noInputFiles{
+	static std::set<frontend::InputMode> const noInputFiles{
 		frontend::InputMode::Help,
 		frontend::InputMode::License,
 		frontend::InputMode::Version
@@ -491,13 +490,13 @@ void CommandLineInterface::readInputFiles()
 	for (boost::filesystem::path const& allowedDirectory: m_options.input.allowedDirectories)
 		m_fileReader.allowDirectory(allowedDirectory);
 
-	map<string, set<boost::filesystem::path>> collisions =
+	std::map<std::string, std::set<boost::filesystem::path>> collisions =
 		m_fileReader.detectSourceUnitNameCollisions(m_options.input.paths);
 	if (!collisions.empty())
 	{
 		auto pathToQuotedString = [](boost::filesystem::path const& _path){ return "\"" + _path.string() + "\""; };
 
-		string message =
+		std::string message =
 			"Source unit name collision detected. "
 			"The specified values of base path and/or include paths would result in multiple "
 			"input files being assigned the same source unit name:\n";
@@ -518,7 +517,7 @@ void CommandLineInterface::readInputFiles()
 			if (!m_options.input.ignoreMissingFiles)
 				solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not found.");
 			else
-				serr() << infile << " is not found. Skipping." << endl;
+				serr() << infile << " is not found. Skipping." << std::endl;
 
 			continue;
 		}
@@ -528,13 +527,13 @@ void CommandLineInterface::readInputFiles()
 			if (!m_options.input.ignoreMissingFiles)
 				solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not a valid file.");
 			else
-				serr() << infile << " is not a valid file. Skipping." << endl;
+				serr() << infile << " is not a valid file. Skipping." << std::endl;
 
 			continue;
 		}
 
 		// NOTE: we ignore the FileNotFound exception as we manually check above
-		string fileContent = readFileAsString(infile);
+		std::string fileContent = readFileAsString(infile);
 		if (m_options.input.mode == InputMode::StandardJson)
 		{
 			solAssert(!m_standardJsonInput.has_value());
@@ -566,12 +565,12 @@ void CommandLineInterface::readInputFiles()
 		solThrow(CommandLineValidationError, "All specified input files either do not exist or are not regular files.");
 }
 
-map<string, Json::Value> CommandLineInterface::parseAstFromInput()
+std::map<std::string, Json::Value> CommandLineInterface::parseAstFromInput()
 {
 	solAssert(m_options.input.mode == InputMode::CompilerWithASTImport);
 
-	map<string, Json::Value> sourceJsons;
-	map<string, string> tmpSources;
+	std::map<std::string, Json::Value> sourceJsons;
+	std::map<std::string, std::string> tmpSources;
 
 	for (SourceCode const& sourceCode: m_fileReader.sourceUnits() | ranges::views::values)
 	{
@@ -581,7 +580,7 @@ map<string, Json::Value> CommandLineInterface::parseAstFromInput()
 
 		for (auto& src: ast["sources"].getMemberNames())
 		{
-			string astKey = ast["sources"][src].isMember("ast") ? "ast" : "AST";
+			std::string astKey = ast["sources"][src].isMember("ast") ? "ast" : "AST";
 
 			astAssert(ast["sources"][src].isMember(astKey), "astkey is not member");
 			astAssert(ast["sources"][src][astKey]["nodeType"].asString() == "SourceUnit",  "Top-level node should be a 'SourceUnit'");
@@ -596,7 +595,7 @@ map<string, Json::Value> CommandLineInterface::parseAstFromInput()
 	return sourceJsons;
 }
 
-void CommandLineInterface::createFile(string const& _fileName, string const& _data)
+void CommandLineInterface::createFile(std::string const& _fileName, std::string const& _data)
 {
 	namespace fs = boost::filesystem;
 
@@ -607,19 +606,19 @@ void CommandLineInterface::createFile(string const& _fileName, string const& _da
 	// The simplest workaround is to use an absolute path.
 	fs::create_directories(fs::absolute(m_options.output.dir));
 
-	string pathName = (m_options.output.dir / _fileName).string();
+	std::string pathName = (m_options.output.dir / _fileName).string();
 	if (fs::exists(pathName) && !m_options.output.overwriteFiles)
 		solThrow(CommandLineOutputError, "Refusing to overwrite existing file \"" + pathName + "\" (use --overwrite to force).");
 
-	ofstream outFile(pathName);
+	std::ofstream outFile(pathName);
 	outFile << _data;
 	if (!outFile)
 		solThrow(CommandLineOutputError, "Could not write to file \"" + pathName + "\".");
 }
 
-void CommandLineInterface::createJson(string const& _fileName, string const& _json)
+void CommandLineInterface::createJson(std::string const& _fileName, std::string const& _json)
 {
-	createFile(boost::filesystem::path(_fileName).stem().string() + string(".json"), _json);
+	createFile(boost::filesystem::path(_fileName).stem().string() + std::string(".json"), _json);
 }
 
 bool CommandLineInterface::run(int _argc, char const* const* _argv)
@@ -640,7 +639,7 @@ bool CommandLineInterface::run(int _argc, char const* const* _argv)
 		// There might be no message in the exception itself if the error output is bulky and has
 		// already been printed to stderr (this happens e.g. for compiler errors).
 		if (_exception.what() != ""s)
-			serr() << _exception.what() << endl;
+			serr() << _exception.what() << std::endl;
 
 		return false;
 	}
@@ -683,7 +682,7 @@ void CommandLineInterface::processInput()
 		solAssert(m_standardJsonInput.has_value());
 
 		StandardCompiler compiler(m_universalCallback.callback(), m_options.formatting.json);
-		sout() << compiler.compile(std::move(m_standardJsonInput.value())) << endl;
+		sout() << compiler.compile(std::move(m_standardJsonInput.value())) << std::endl;
 		m_standardJsonInput.reset();
 		break;
 	}
@@ -707,22 +706,22 @@ void CommandLineInterface::processInput()
 
 void CommandLineInterface::printVersion()
 {
-	sout() << "solc, the solidity compiler commandline interface" << endl;
-	sout() << "Version: " << solidity::frontend::VersionString << endl;
+	sout() << "solc, the solidity compiler commandline interface" << std::endl;
+	sout() << "Version: " << solidity::frontend::VersionString << std::endl;
 }
 
 void CommandLineInterface::printLicense()
 {
-	sout() << otherLicenses << endl;
+	sout() << otherLicenses << std::endl;
 	// This is a static variable generated by cmake from LICENSE.txt
-	sout() << licenseText << endl;
+	sout() << licenseText << std::endl;
 }
 
 void CommandLineInterface::compile()
 {
 	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
-	m_compiler = make_unique<CompilerStack>(m_universalCallback.callback());
+	m_compiler = std::make_unique<CompilerStack>(m_universalCallback.callback());
 
 	SourceReferenceFormatter formatter(serr(false), *m_compiler, coloredOutput(m_options), m_options.formatting.withErrorIds);
 
@@ -840,7 +839,7 @@ void CommandLineInterface::handleCombinedJSON()
 	Json::Value output(Json::objectValue);
 
 	output[g_strVersion] = frontend::VersionString;
-	vector<string> contracts = m_compiler->contractNames();
+	std::vector<std::string> contracts = m_compiler->contractNames();
 
 	// NOTE: The state checks here are more strict that in Standard JSON. There we allow
 	// requesting certain outputs even if compilation fails as long as analysis went ok.
@@ -848,7 +847,7 @@ void CommandLineInterface::handleCombinedJSON()
 
 	if (!contracts.empty())
 		output[g_strContracts] = Json::Value(Json::objectValue);
-	for (string const& contractName: contracts)
+	for (std::string const& contractName: contracts)
 	{
 		Json::Value& contractData = output[g_strContracts][contractName] = Json::objectValue;
 		if (m_options.compiler.combinedJsonRequests->abi && compilationSuccess)
@@ -922,11 +921,11 @@ void CommandLineInterface::handleCombinedJSON()
 		}
 	}
 
-	string json = jsonPrint(removeNullMembers(std::move(output)), m_options.formatting.json);
+	std::string json = jsonPrint(removeNullMembers(std::move(output)), m_options.formatting.json);
 	if (!m_options.output.dir.empty())
 		createJson("combined", json);
 	else
-		sout() << json << endl;
+		sout() << json << std::endl;
 }
 
 void CommandLineInterface::handleAst()
@@ -936,7 +935,7 @@ void CommandLineInterface::handleAst()
 	if (!m_options.compiler.outputs.astCompactJson)
 		return;
 
-	vector<ASTNode const*> asts;
+	std::vector<ASTNode const*> asts;
 	for (auto const& sourceCode: m_fileReader.sourceUnits())
 		asts.push_back(&m_compiler->ast(sourceCode.first));
 
@@ -944,8 +943,8 @@ void CommandLineInterface::handleAst()
 	{
 		for (auto const& sourceCode: m_fileReader.sourceUnits())
 		{
-			stringstream data;
-			string postfix = "";
+			std::stringstream data;
+			std::string postfix = "";
 			ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(data, m_compiler->ast(sourceCode.first), m_options.formatting.json);
 			postfix += "_json";
 			boost::filesystem::path path(sourceCode.first);
@@ -954,10 +953,10 @@ void CommandLineInterface::handleAst()
 	}
 	else
 	{
-		sout() << "JSON AST (compact format):" << endl << endl;
+		sout() << "JSON AST (compact format):" << std::endl << std::endl;
 		for (auto const& sourceCode: m_fileReader.sourceUnits())
 		{
-			sout() << endl << "======= " << sourceCode.first << " =======" << endl;
+			sout() << std::endl << "======= " << sourceCode.first << " =======" << std::endl;
 			ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(sout(), m_compiler->ast(sourceCode.first), m_options.formatting.json);
 		}
 	}
@@ -975,11 +974,11 @@ void CommandLineInterface::link()
 	solAssert(m_options.input.mode == InputMode::Linker);
 
 	// Map from how the libraries will be named inside the bytecode to their addresses.
-	map<string, h160> librariesReplacements;
+	std::map<std::string, h160> librariesReplacements;
 	int const placeholderSize = 40; // 20 bytes or 40 hex characters
 	for (auto const& library: m_options.linker.libraries)
 	{
-		string const& name = library.first;
+		std::string const& name = library.first;
 		// Library placeholders are 40 hex digits (20 bytes) that start and end with '__'.
 		// This leaves 36 characters for the library identifier. The identifier used to
 		// be just the cropped or '_'-padded library name, but this changed to
@@ -987,7 +986,7 @@ void CommandLineInterface::link()
 		// We support both ways of linking here.
 		librariesReplacements["__" + evmasm::LinkerObject::libraryPlaceholder(name) + "__"] = library.second;
 
-		string replacement = "__";
+		std::string replacement = "__";
 		for (size_t i = 0; i < placeholderSize - 4; ++i)
 			replacement.push_back(i < name.size() ? name[i] : '_');
 		replacement += "__";
@@ -1010,18 +1009,18 @@ void CommandLineInterface::link()
 			)
 				solThrow(
 					CommandLineExecutionError,
-					"Error in binary object file " + src.first + " at position " + to_string(it - src.second.begin()) + "\n" +
-					'"' + string(it, it + min(placeholderSize, static_cast<int>(end - it))) + "\" is not a valid link reference."
+					"Error in binary object file " + src.first + " at position " + std::to_string(it - src.second.begin()) + "\n" +
+					'"' + std::string(it, it + std::min(placeholderSize, static_cast<int>(end - it))) + "\" is not a valid link reference."
 				);
 
-			string foundPlaceholder(it, it + placeholderSize);
+			std::string foundPlaceholder(it, it + placeholderSize);
 			if (librariesReplacements.count(foundPlaceholder))
 			{
-				string hexStr(util::toHex(librariesReplacements.at(foundPlaceholder).asBytes()));
+				std::string hexStr(util::toHex(librariesReplacements.at(foundPlaceholder).asBytes()));
 				copy(hexStr.begin(), hexStr.end(), it);
 			}
 			else
-				serr() << "Reference \"" << foundPlaceholder << "\" in file \"" << src.first << "\" still unresolved." << endl;
+				serr() << "Reference \"" << foundPlaceholder << "\" in file \"" << src.first << "\" still unresolved." << std::endl;
 			it += placeholderSize;
 		}
 		// Remove hints for resolved libraries.
@@ -1039,25 +1038,25 @@ void CommandLineInterface::writeLinkedFiles()
 
 	for (auto const& src: m_fileReader.sourceUnits())
 		if (src.first == g_stdinFileName)
-			sout() << src.second << endl;
+			sout() << src.second << std::endl;
 		else
 		{
-			ofstream outFile(src.first);
+			std::ofstream outFile(src.first);
 			outFile << src.second;
 			if (!outFile)
 				solThrow(CommandLineOutputError, "Could not write to file " + src.first + ". Aborting.");
 		}
-	sout() << "Linking completed." << endl;
+	sout() << "Linking completed." << std::endl;
 }
 
-string CommandLineInterface::libraryPlaceholderHint(string const& _libraryName)
+std::string CommandLineInterface::libraryPlaceholderHint(std::string const& _libraryName)
 {
 	return "// " + evmasm::LinkerObject::libraryPlaceholder(_libraryName) + " -> " + _libraryName;
 }
 
-string CommandLineInterface::objectWithLinkRefsHex(evmasm::LinkerObject const& _obj)
+std::string CommandLineInterface::objectWithLinkRefsHex(evmasm::LinkerObject const& _obj)
 {
-	string out = _obj.toHex();
+	std::string out = _obj.toHex();
 	if (!_obj.linkReferences.empty())
 	{
 		out += "\n";
@@ -1072,7 +1071,7 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
 	solAssert(m_options.input.mode == InputMode::Assembler);
 
 	bool successful = true;
-	map<string, yul::YulStack> yulStacks;
+	std::map<std::string, yul::YulStack> yulStacks;
 	for (auto const& src: m_fileReader.sourceUnits())
 	{
 		auto& stack = yulStacks[src.first] = yul::YulStack(
@@ -1114,8 +1113,8 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
 	for (auto const& src: m_fileReader.sourceUnits())
 	{
 		solAssert(_targetMachine == yul::YulStack::Machine::EVM);
-		string machine = "EVM";
-		sout() << endl << "======= " << src.first << " (" << machine << ") =======" << endl;
+		std::string machine = "EVM";
+		sout() << std::endl << "======= " << src.first << " (" << machine << ") =======" << std::endl;
 
 		yul::YulStack& stack = yulStacks[src.first];
 
@@ -1123,8 +1122,8 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
 		{
 			// NOTE: This actually outputs unoptimized code when the optimizer is disabled but
 			// 'ir' output in StandardCompiler works the same way.
-			sout() << endl << "Pretty printed source:" << endl;
-			sout() << stack.print() << endl;
+			sout() << std::endl << "Pretty printed source:" << std::endl;
+			sout() << stack.print() << std::endl;
 		}
 
 		yul::MachineAssemblyObject object;
@@ -1133,25 +1132,25 @@ void CommandLineInterface::assembleYul(yul::YulStack::Language _language, yul::Y
 
 		if (m_options.compiler.outputs.binary)
 		{
-			sout() << endl << "Binary representation:" << endl;
+			sout() << std::endl << "Binary representation:" << std::endl;
 			if (object.bytecode)
-				sout() << object.bytecode->toHex() << endl;
+				sout() << object.bytecode->toHex() << std::endl;
 			else
-				serr() << "No binary representation found." << endl;
+				serr() << "No binary representation found." << std::endl;
 		}
 		if (m_options.compiler.outputs.astCompactJson)
 		{
-			sout() << "AST:" <<  endl <<  endl;
-			sout() << util::jsonPrint(stack.astJson(), m_options.formatting.json) << endl;
+			sout() << "AST:" << std::endl << std::endl;
+			sout() << util::jsonPrint(stack.astJson(), m_options.formatting.json) << std::endl;
 		}
 		solAssert(_targetMachine == yul::YulStack::Machine::EVM, "");
 		if (m_options.compiler.outputs.asm_)
 		{
-			sout() << endl << "Text representation:" << endl;
+			sout() << std::endl << "Text representation:" << std::endl;
 			if (!object.assembly.empty())
-				sout() << object.assembly << endl;
+				sout() << object.assembly << std::endl;
 			else
-				serr() << "No text representation found." << endl;
+				serr() << "No text representation found." << std::endl;
 		}
 	}
 }
@@ -1173,15 +1172,15 @@ void CommandLineInterface::outputCompilationResults()
 		// we can safely assume that full compilation was performed and successful.
 		solAssert(m_options.output.stopAfter >= CompilerStack::State::CompilationSuccessful);
 
-		for (string const& contract: m_compiler->contractNames())
+		for (std::string const& contract: m_compiler->contractNames())
 		{
 			if (needsHumanTargetedStdout(m_options))
-				sout() << endl << "======= " << contract << " =======" << endl;
+				sout() << std::endl << "======= " << contract << " =======" << std::endl;
 
 			// do we need EVM assembly?
 			if (m_options.compiler.outputs.asm_ || m_options.compiler.outputs.asmJson)
 			{
-				string ret;
+				std::string ret;
 				if (m_options.compiler.outputs.asmJson)
 					ret = util::jsonPrint(removeNullMembers(m_compiler->assemblyJSON(contract)), m_options.formatting.json);
 				else
@@ -1190,7 +1189,7 @@ void CommandLineInterface::outputCompilationResults()
 				if (!m_options.output.dir.empty())
 					createFile(m_compiler->filesystemFriendlyName(contract) + (m_options.compiler.outputs.asmJson ? "_evm.json" : ".evm"), ret);
 				else
-					sout() << "EVM assembly:" << endl << ret << endl;
+					sout() << "EVM assembly:" << std::endl << ret << std::endl;
 			}
 
 			if (m_options.compiler.estimateGas)
@@ -1213,11 +1212,11 @@ void CommandLineInterface::outputCompilationResults()
 	if (!m_hasOutput)
 	{
 		if (!m_options.output.dir.empty())
-			sout() << "Compiler run successful. Artifact(s) can be found in directory " << m_options.output.dir << "." << endl;
+			sout() << "Compiler run successful. Artifact(s) can be found in directory " << m_options.output.dir << "." << std::endl;
 		else if (m_compiler->contractNames().empty())
-			sout() << "Compiler run successful. No contracts to compile." << endl;
+			sout() << "Compiler run successful. No contracts to compile." << std::endl;
 		else
-			sout() << "Compiler run successful. No output generated." << endl;
+			sout() << "Compiler run successful. No output generated." << std::endl;
 	}
 }
 
diff --git a/solc/CommandLineParser.cpp b/solc/CommandLineParser.cpp
index 8ac4f969c..53f481ae8 100644
--- a/solc/CommandLineParser.cpp
+++ b/solc/CommandLineParser.cpp
@@ -30,7 +30,6 @@
 #include <range/v3/view/filter.hpp>
 #include <range/v3/range/conversion.hpp>
 
-using namespace std;
 using namespace solidity::langutil;
 
 namespace po = boost::program_options;
@@ -38,59 +37,59 @@ namespace po = boost::program_options;
 namespace solidity::frontend
 {
 
-static string const g_strAllowPaths = "allow-paths";
-static string const g_strBasePath = "base-path";
-static string const g_strIncludePath = "include-path";
-static string const g_strAssemble = "assemble";
-static string const g_strCombinedJson = "combined-json";
-static string const g_strEVM = "evm";
-static string const g_strEVMVersion = "evm-version";
-static string const g_strEOFVersion = "experimental-eof-version";
-static string const g_strViaIR = "via-ir";
-static string const g_strExperimentalViaIR = "experimental-via-ir";
-static string const g_strGas = "gas";
-static string const g_strHelp = "help";
-static string const g_strImportAst = "import-ast";
-static string const g_strInputFile = "input-file";
-static string const g_strYul = "yul";
-static string const g_strYulDialect = "yul-dialect";
-static string const g_strDebugInfo = "debug-info";
-static string const g_strIPFS = "ipfs";
-static string const g_strLicense = "license";
-static string const g_strLibraries = "libraries";
-static string const g_strLink = "link";
-static string const g_strLSP = "lsp";
-static string const g_strMachine = "machine";
-static string const g_strNoCBORMetadata = "no-cbor-metadata";
-static string const g_strMetadataHash = "metadata-hash";
-static string const g_strMetadataLiteral = "metadata-literal";
-static string const g_strModelCheckerContracts = "model-checker-contracts";
-static string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
-static string const g_strModelCheckerEngine = "model-checker-engine";
-static string const g_strModelCheckerExtCalls = "model-checker-ext-calls";
-static string const g_strModelCheckerInvariants = "model-checker-invariants";
-static string const g_strModelCheckerPrintQuery = "model-checker-print-query";
-static string const g_strModelCheckerShowProvedSafe = "model-checker-show-proved-safe";
-static string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
-static string const g_strModelCheckerShowUnsupported = "model-checker-show-unsupported";
-static string const g_strModelCheckerSolvers = "model-checker-solvers";
-static string const g_strModelCheckerTargets = "model-checker-targets";
-static string const g_strModelCheckerTimeout = "model-checker-timeout";
-static string const g_strModelCheckerBMCLoopIterations = "model-checker-bmc-loop-iterations";
-static string const g_strNone = "none";
-static string const g_strNoOptimizeYul = "no-optimize-yul";
-static string const g_strOptimize = "optimize";
-static string const g_strOptimizeRuns = "optimize-runs";
-static string const g_strOptimizeYul = "optimize-yul";
-static string const g_strYulOptimizations = "yul-optimizations";
-static string const g_strOutputDir = "output-dir";
-static string const g_strOverwrite = "overwrite";
-static string const g_strRevertStrings = "revert-strings";
-static string const g_strStopAfter = "stop-after";
-static string const g_strParsing = "parsing";
+static std::string const g_strAllowPaths = "allow-paths";
+static std::string const g_strBasePath = "base-path";
+static std::string const g_strIncludePath = "include-path";
+static std::string const g_strAssemble = "assemble";
+static std::string const g_strCombinedJson = "combined-json";
+static std::string const g_strEVM = "evm";
+static std::string const g_strEVMVersion = "evm-version";
+static std::string const g_strEOFVersion = "experimental-eof-version";
+static std::string const g_strViaIR = "via-ir";
+static std::string const g_strExperimentalViaIR = "experimental-via-ir";
+static std::string const g_strGas = "gas";
+static std::string const g_strHelp = "help";
+static std::string const g_strImportAst = "import-ast";
+static std::string const g_strInputFile = "input-file";
+static std::string const g_strYul = "yul";
+static std::string const g_strYulDialect = "yul-dialect";
+static std::string const g_strDebugInfo = "debug-info";
+static std::string const g_strIPFS = "ipfs";
+static std::string const g_strLicense = "license";
+static std::string const g_strLibraries = "libraries";
+static std::string const g_strLink = "link";
+static std::string const g_strLSP = "lsp";
+static std::string const g_strMachine = "machine";
+static std::string const g_strNoCBORMetadata = "no-cbor-metadata";
+static std::string const g_strMetadataHash = "metadata-hash";
+static std::string const g_strMetadataLiteral = "metadata-literal";
+static std::string const g_strModelCheckerContracts = "model-checker-contracts";
+static std::string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
+static std::string const g_strModelCheckerEngine = "model-checker-engine";
+static std::string const g_strModelCheckerExtCalls = "model-checker-ext-calls";
+static std::string const g_strModelCheckerInvariants = "model-checker-invariants";
+static std::string const g_strModelCheckerPrintQuery = "model-checker-print-query";
+static std::string const g_strModelCheckerShowProvedSafe = "model-checker-show-proved-safe";
+static std::string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
+static std::string const g_strModelCheckerShowUnsupported = "model-checker-show-unsupported";
+static std::string const g_strModelCheckerSolvers = "model-checker-solvers";
+static std::string const g_strModelCheckerTargets = "model-checker-targets";
+static std::string const g_strModelCheckerTimeout = "model-checker-timeout";
+static std::string const g_strModelCheckerBMCLoopIterations = "model-checker-bmc-loop-iterations";
+static std::string const g_strNone = "none";
+static std::string const g_strNoOptimizeYul = "no-optimize-yul";
+static std::string const g_strOptimize = "optimize";
+static std::string const g_strOptimizeRuns = "optimize-runs";
+static std::string const g_strOptimizeYul = "optimize-yul";
+static std::string const g_strYulOptimizations = "yul-optimizations";
+static std::string const g_strOutputDir = "output-dir";
+static std::string const g_strOverwrite = "overwrite";
+static std::string const g_strRevertStrings = "revert-strings";
+static std::string const g_strStopAfter = "stop-after";
+static std::string const g_strParsing = "parsing";
 
 /// Possible arguments to for --revert-strings
-static set<string> const g_revertStringsArgs
+static std::set<std::string> const g_revertStringsArgs
 {
 	revertStringsToString(RevertStrings::Default),
 	revertStringsToString(RevertStrings::Strip),
@@ -98,40 +97,40 @@ static set<string> const g_revertStringsArgs
 	revertStringsToString(RevertStrings::VerboseDebug)
 };
 
-static string const g_strSources = "sources";
-static string const g_strSourceList = "sourceList";
-static string const g_strStandardJSON = "standard-json";
-static string const g_strStrictAssembly = "strict-assembly";
-static string const g_strSwarm = "swarm";
-static string const g_strPrettyJson = "pretty-json";
-static string const g_strJsonIndent = "json-indent";
-static string const g_strVersion = "version";
-static string const g_strIgnoreMissingFiles = "ignore-missing";
-static string const g_strColor = "color";
-static string const g_strNoColor = "no-color";
-static string const g_strErrorIds = "error-codes";
+static std::string const g_strSources = "sources";
+static std::string const g_strSourceList = "sourceList";
+static std::string const g_strStandardJSON = "standard-json";
+static std::string const g_strStrictAssembly = "strict-assembly";
+static std::string const g_strSwarm = "swarm";
+static std::string const g_strPrettyJson = "pretty-json";
+static std::string const g_strJsonIndent = "json-indent";
+static std::string const g_strVersion = "version";
+static std::string const g_strIgnoreMissingFiles = "ignore-missing";
+static std::string const g_strColor = "color";
+static std::string const g_strNoColor = "no-color";
+static std::string const g_strErrorIds = "error-codes";
 
 /// Possible arguments to for --machine
-static set<string> const g_machineArgs
+static std::set<std::string> const g_machineArgs
 {
 	g_strEVM
 };
 
 /// Possible arguments to for --yul-dialect
-static set<string> const g_yulDialectArgs
+static std::set<std::string> const g_yulDialectArgs
 {
 	g_strEVM
 };
 
 /// Possible arguments to for --metadata-hash
-static set<string> const g_metadataHashArgs
+static std::set<std::string> const g_metadataHashArgs
 {
 	g_strIPFS,
 	g_strSwarm,
 	g_strNone
 };
 
-static map<InputMode, string> const g_inputModeName = {
+static std::map<InputMode, std::string> const g_inputModeName = {
 	{InputMode::Help, "help"},
 	{InputMode::License, "license"},
 	{InputMode::Version, "version"},
@@ -143,7 +142,7 @@ static map<InputMode, string> const g_inputModeName = {
 	{InputMode::LanguageServer, "language server (LSP)"},
 };
 
-void CommandLineParser::checkMutuallyExclusive(vector<string> const& _optionNames)
+void CommandLineParser::checkMutuallyExclusive(std::vector<std::string> const& _optionNames)
 {
 	if (countEnabledOptions(_optionNames) > 1)
 	{
@@ -163,9 +162,9 @@ bool CompilerOutputs::operator==(CompilerOutputs const& _other) const noexcept
 	return true;
 }
 
-ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
+std::ostream& operator<<(std::ostream& _out, CompilerOutputs const& _selection)
 {
-	vector<string> serializedSelection;
+	std::vector<std::string> serializedSelection;
 	for (auto&& [componentName, component]: CompilerOutputs::componentMap())
 		if (_selection.*component)
 			serializedSelection.push_back(CompilerOutputs::componentName(component));
@@ -173,7 +172,7 @@ ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
 	return _out << util::joinHumanReadable(serializedSelection, ",");
 }
 
-string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
+std::string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
 {
 	solAssert(_component, "");
 
@@ -194,9 +193,9 @@ bool CombinedJsonRequests::operator==(CombinedJsonRequests const& _other) const
 }
 
 
-ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
+std::ostream& operator<<(std::ostream& _out, CombinedJsonRequests const& _requests)
 {
-	vector<string> serializedRequests;
+	std::vector<std::string> serializedRequests;
 	for (auto&& [componentName, component]: CombinedJsonRequests::componentMap())
 		if (_requests.*component)
 			serializedRequests.push_back(CombinedJsonRequests::componentName(component));
@@ -204,7 +203,7 @@ ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
 	return _out << util::joinHumanReadable(serializedRequests, ",");
 }
 
-string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
+std::string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
 {
 	solAssert(_component, "");
 
@@ -274,11 +273,11 @@ OptimiserSettings CommandLineOptions::optimiserSettings() const
 
 	if (optimizer.yulSteps.has_value())
 	{
-		string const fullSequence = optimizer.yulSteps.value();
+		std::string const fullSequence = optimizer.yulSteps.value();
 		auto const delimiterPos = fullSequence.find(":");
 		settings.yulOptimiserSteps = fullSequence.substr(0, delimiterPos);
 
-		if (delimiterPos != string::npos)
+		if (delimiterPos != std::string::npos)
 			settings.yulOptimiserCleanupSteps = fullSequence.substr(delimiterPos + 1);
 		else
 			solAssert(settings.yulOptimiserCleanupSteps == OptimiserSettings::DefaultYulOptimiserCleanupSteps);
@@ -298,11 +297,11 @@ void CommandLineParser::parseInputPathsAndRemappings()
 	m_options.input.ignoreMissingFiles = (m_args.count(g_strIgnoreMissingFiles) > 0);
 
 	if (m_args.count(g_strInputFile))
-		for (string const& positionalArg: m_args[g_strInputFile].as<vector<string>>())
+		for (std::string const& positionalArg: m_args[g_strInputFile].as<std::vector<std::string>>())
 		{
 			if (ImportRemapper::isRemapping(positionalArg))
 			{
-				optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
+				std::optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
 				if (!remapping.has_value())
 					solThrow(CommandLineValidationError, "Invalid remapping: \"" + positionalArg + "\".");
 
@@ -353,10 +352,10 @@ void CommandLineParser::parseInputPathsAndRemappings()
 		);
 }
 
-void CommandLineParser::parseLibraryOption(string const& _input)
+void CommandLineParser::parseLibraryOption(std::string const& _input)
 {
 	namespace fs = boost::filesystem;
-	string data = _input;
+	std::string data = _input;
 	try
 	{
 		if (fs::is_regular_file(_input))
@@ -375,19 +374,19 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 		// Should not happen if `fs::is_regular_file` is correct.
 	}
 
-	vector<string> libraries;
+	std::vector<std::string> libraries;
 	boost::split(libraries, data, boost::is_space() || boost::is_any_of(","), boost::token_compress_on);
-	for (string const& lib: libraries)
+	for (std::string const& lib: libraries)
 		if (!lib.empty())
 		{
 			//search for equal sign or last colon in string as our binaries output placeholders in the form of file=Name or file:Name
 			//so we need to search for `=` or `:` in the string
 			auto separator = lib.rfind('=');
 			bool isSeparatorEqualSign = true;
-			if (separator == string::npos)
+			if (separator == std::string::npos)
 			{
 				separator = lib.rfind(':');
-				if (separator == string::npos)
+				if (separator == std::string::npos)
 					solThrow(
 						CommandLineValidationError,
 						"Equal sign separator missing in library address specifier \"" + lib + "\""
@@ -402,7 +401,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 						"Only one equal sign \"=\" is allowed in the address string \"" + lib + "\"."
 					);
 
-			string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
+			std::string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
 			boost::trim(libName);
 			if (m_options.linker.libraries.count(libName))
 				solThrow(
@@ -410,7 +409,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 					"Address specified more than once for library \"" + libName + "\"."
 				);
 
-			string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
+			std::string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
 			boost::trim(addrString);
 			if (addrString.empty())
 				solThrow(
@@ -433,7 +432,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 				solThrow(
 					CommandLineValidationError,
 					"Invalid length for address for library \"" + libName + "\": " +
-					to_string(addrString.length()) + " instead of 40 characters."
+					std::to_string(addrString.length()) + " instead of 40 characters."
 				);
 			if (!util::passesAddressChecksum(addrString, false))
 				solThrow(
@@ -454,14 +453,14 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 
 void CommandLineParser::parseOutputSelection()
 {
-	static auto outputSupported = [](InputMode _mode, string_view _outputName)
+	static auto outputSupported = [](InputMode _mode, std::string_view _outputName)
 	{
-		static set<string> const compilerModeOutputs = (
+		static std::set<std::string> const compilerModeOutputs = (
 			CompilerOutputs::componentMap() |
 			ranges::views::keys |
-			ranges::to<set>()
+			ranges::to<std::set>()
 		);
-		static set<string> const assemblerModeOutputs = {
+		static std::set<std::string> const assemblerModeOutputs = {
 			CompilerOutputs::componentName(&CompilerOutputs::asm_),
 			CompilerOutputs::componentName(&CompilerOutputs::binary),
 			CompilerOutputs::componentName(&CompilerOutputs::irOptimized),
@@ -500,7 +499,7 @@ void CommandLineParser::parseOutputSelection()
 		m_options.compiler.outputs.irOptimized = true;
 	}
 
-	vector<string> unsupportedOutputs;
+	std::vector<std::string> unsupportedOutputs;
 	for (auto&& [optionName, outputComponent]: CompilerOutputs::componentMap())
 		if (m_options.compiler.outputs.*outputComponent && !outputSupported(m_options.input.mode, optionName))
 			unsupportedOutputs.push_back(optionName);
@@ -547,12 +546,12 @@ General Information)").c_str(),
 	inputOptions.add_options()
 		(
 			g_strBasePath.c_str(),
-			po::value<string>()->value_name("path"),
+			po::value<std::string>()->value_name("path"),
 			"Use the given path as the root of the source tree instead of the root of the filesystem."
 		)
 		(
 			g_strIncludePath.c_str(),
-			po::value<vector<string>>()->value_name("path"),
+			po::value<std::vector<std::string>>()->value_name("path"),
 			"Make an additional source directory available to the default import callback. "
 			"Use this option if you want to import contracts whose location is not fixed in relation "
 			"to your main source tree, e.g. third-party libraries installed using a package manager. "
@@ -561,7 +560,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strAllowPaths.c_str(),
-			po::value<string>()->value_name("path(s)"),
+			po::value<std::string>()->value_name("path(s)"),
 			"Allow a given path for imports. A list of paths can be supplied by separating them with a comma."
 		)
 		(
@@ -575,7 +574,7 @@ General Information)").c_str(),
 	outputOptions.add_options()
 		(
 			(g_strOutputDir + ",o").c_str(),
-			po::value<string>()->value_name("path"),
+			po::value<std::string>()->value_name("path"),
 			"If given, creates one file per output component and contract/file at the specified directory."
 		)
 		(
@@ -584,7 +583,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strEVMVersion.c_str(),
-			po::value<string>()->value_name("version")->default_value(EVMVersion{}.name()),
+			po::value<std::string>()->value_name("version")->default_value(EVMVersion{}.name()),
 			"Select desired EVM version. Either homestead, tangerineWhistle, spuriousDragon, "
 			"byzantium, constantinople, petersburg, istanbul, berlin, london, paris or shanghai."
 		)
@@ -610,19 +609,19 @@ General Information)").c_str(),
 		)
 		(
 			g_strRevertStrings.c_str(),
-			po::value<string>()->value_name(util::joinHumanReadable(g_revertStringsArgs, ",")),
+			po::value<std::string>()->value_name(util::joinHumanReadable(g_revertStringsArgs, ",")),
 			"Strip revert (and require) reason strings or add additional debugging information."
 		)
 		(
 			g_strDebugInfo.c_str(),
-			po::value<string>()->default_value(util::toString(DebugInfoSelection::Default())),
+			po::value<std::string>()->default_value(util::toString(DebugInfoSelection::Default())),
 			("Debug info components to be included in the produced EVM assembly and Yul code. "
 			"Value can be all, none or a comma-separated list containing one or more of the "
 			"following components: " + util::joinHumanReadable(DebugInfoSelection::componentMap() | ranges::views::keys) + ".").c_str()
 		)
 		(
 			g_strStopAfter.c_str(),
-			po::value<string>()->value_name("stage"),
+			po::value<std::string>()->value_name("stage"),
 			"Stop execution after the given compiler stage. Valid options: \"parsing\"."
 		)
 	;
@@ -670,12 +669,12 @@ General Information)").c_str(),
 	assemblyModeOptions.add_options()
 		(
 			g_strMachine.c_str(),
-			po::value<string>()->value_name(util::joinHumanReadable(g_machineArgs, ",")),
+			po::value<std::string>()->value_name(util::joinHumanReadable(g_machineArgs, ",")),
 			"Target machine in assembly or Yul mode."
 		)
 		(
 			g_strYulDialect.c_str(),
-			po::value<string>()->value_name(util::joinHumanReadable(g_yulDialectArgs, ",")),
+			po::value<std::string>()->value_name(util::joinHumanReadable(g_yulDialectArgs, ",")),
 			"Input dialect to use in assembly or yul mode."
 		)
 	;
@@ -685,7 +684,7 @@ General Information)").c_str(),
 	linkerModeOptions.add_options()
 		(
 			g_strLibraries.c_str(),
-			po::value<vector<string>>()->value_name("libs"),
+			po::value<std::vector<std::string>>()->value_name("libs"),
 			"Direct string or file containing library addresses. Syntax: "
 			"<libraryName>=<address> [, or whitespace] ...\n"
 			"Address is interpreted as a hex string prefixed by 0x."
@@ -748,7 +747,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strCombinedJson.c_str(),
-			po::value<string>()->value_name(util::joinHumanReadable(CombinedJsonRequests::componentMap() | ranges::views::keys, ",")),
+			po::value<std::string>()->value_name(util::joinHumanReadable(CombinedJsonRequests::componentMap() | ranges::views::keys, ",")),
 			"Output a single json document containing the specified information."
 		)
 	;
@@ -762,7 +761,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strMetadataHash.c_str(),
-			po::value<string>()->value_name(util::joinHumanReadable(g_metadataHashArgs, ",")),
+			po::value<std::string>()->value_name(util::joinHumanReadable(g_metadataHashArgs, ",")),
 			"Choose hash method for the bytecode metadata or disable it."
 		)
 		(
@@ -798,7 +797,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strYulOptimizations.c_str(),
-			po::value<string>()->value_name("steps"),
+			po::value<std::string>()->value_name("steps"),
 			"Forces Yul optimizer to use the specified sequence of optimization steps instead of the built-in one."
 		)
 	;
@@ -808,7 +807,7 @@ General Information)").c_str(),
 	smtCheckerOptions.add_options()
 		(
 			g_strModelCheckerContracts.c_str(),
-			po::value<string>()->value_name("default,<source>:<contract>")->default_value("default"),
+			po::value<std::string>()->value_name("default,<source>:<contract>")->default_value("default"),
 			"Select which contracts should be analyzed using the form <source>:<contract>."
 			"Multiple pairs <source>:<contract> can be selected at the same time, separated by a comma "
 			"and no spaces."
@@ -820,18 +819,18 @@ General Information)").c_str(),
 		)
 		(
 			g_strModelCheckerEngine.c_str(),
-			po::value<string>()->value_name("all,bmc,chc,none")->default_value("none"),
+			po::value<std::string>()->value_name("all,bmc,chc,none")->default_value("none"),
 			"Select model checker engine."
 		)
 		(
 			g_strModelCheckerExtCalls.c_str(),
-			po::value<string>()->value_name("untrusted,trusted")->default_value("untrusted"),
+			po::value<std::string>()->value_name("untrusted,trusted")->default_value("untrusted"),
 			"Select whether to assume (trusted) that external calls always invoke"
 			" the code given by the type of the contract, if that code is available."
 		)
 		(
 			g_strModelCheckerInvariants.c_str(),
-			po::value<string>()->value_name("default,all,contract,reentrancy")->default_value("default"),
+			po::value<std::string>()->value_name("default,all,contract,reentrancy")->default_value("default"),
 			"Select whether to report inferred contract inductive invariants."
 			" Multiple types of invariants can be selected at the same time, separated by a comma and no spaces."
 			" By default no invariants are reported."
@@ -854,12 +853,12 @@ General Information)").c_str(),
 		)
 		(
 			g_strModelCheckerSolvers.c_str(),
-			po::value<string>()->value_name("cvc4,eld,z3,smtlib2")->default_value("z3"),
+			po::value<std::string>()->value_name("cvc4,eld,z3,smtlib2")->default_value("z3"),
 			"Select model checker solvers."
 		)
 		(
 			g_strModelCheckerTargets.c_str(),
-			po::value<string>()->value_name("default,all,constantCondition,underflow,overflow,divByZero,balance,assert,popEmptyArray,outOfBounds")->default_value("default"),
+			po::value<std::string>()->value_name("default,all,constantCondition,underflow,overflow,divByZero,balance,assert,popEmptyArray,outOfBounds")->default_value("default"),
 			"Select model checker verification targets."
 			"Multiple targets can be selected at the same time, separated by a comma and no spaces."
 			" By default all targets except underflow and overflow are selected."
@@ -880,7 +879,7 @@ General Information)").c_str(),
 	;
 	desc.add(smtCheckerOptions);
 
-	desc.add_options()(g_strInputFile.c_str(), po::value<vector<string>>(), "input file");
+	desc.add_options()(g_strInputFile.c_str(), po::value<std::vector<std::string>>(), "input file");
 	return desc;
 }
 
@@ -954,7 +953,7 @@ void CommandLineParser::processArgs()
 	)
 		return;
 
-	map<string, set<InputMode>> validOptionInputModeCombinations = {
+	std::map<std::string, std::set<InputMode>> validOptionInputModeCombinations = {
 		// TODO: This should eventually contain all options.
 		{g_strExperimentalViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
@@ -975,7 +974,7 @@ void CommandLineParser::processArgs()
 		{g_strModelCheckerContracts, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerTargets, {InputMode::Compiler, InputMode::CompilerWithASTImport}}
 	};
-	vector<string> invalidOptionsForCurrentInputMode;
+	std::vector<std::string> invalidOptionsForCurrentInputMode;
 	for (auto const& [optionName, inputModes]: validOptionInputModeCombinations)
 	{
 		if (
@@ -999,7 +998,7 @@ void CommandLineParser::processArgs()
 	checkMutuallyExclusive({g_strColor, g_strNoColor});
 	checkMutuallyExclusive({g_strStopAfter, g_strGas});
 
-	for (string const& option: CompilerOutputs::componentMap() | ranges::views::keys)
+	for (std::string const& option: CompilerOutputs::componentMap() | ranges::views::keys)
 		if (option != CompilerOutputs::componentName(&CompilerOutputs::astCompactJson))
 			checkMutuallyExclusive({g_strStopAfter, option});
 
@@ -1015,7 +1014,7 @@ void CommandLineParser::processArgs()
 				"Option --" + g_strOptimizeRuns + " is only valid in compiler and assembler modes."
 			);
 
-		for (string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
+		for (std::string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
 			if (m_args.count(option) > 0)
 				solThrow(
 					CommandLineValidationError,
@@ -1038,8 +1037,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strRevertStrings))
 	{
-		string revertStringsString = m_args[g_strRevertStrings].as<string>();
-		optional<RevertStrings> revertStrings = revertStringsFromString(revertStringsString);
+		std::string revertStringsString = m_args[g_strRevertStrings].as<std::string>();
+		std::optional<RevertStrings> revertStrings = revertStringsFromString(revertStringsString);
 		if (!revertStrings)
 			solThrow(
 				CommandLineValidationError,
@@ -1055,7 +1054,7 @@ void CommandLineParser::processArgs()
 
 	if (!m_args[g_strDebugInfo].defaulted())
 	{
-		string optionValue = m_args[g_strDebugInfo].as<string>();
+		std::string optionValue = m_args[g_strDebugInfo].as<std::string>();
 		m_options.output.debugInfoSelection = DebugInfoSelection::fromString(optionValue);
 		if (!m_options.output.debugInfoSelection.has_value())
 			solThrow(CommandLineValidationError, "Invalid value for --" + g_strDebugInfo + " option: " + optionValue);
@@ -1067,7 +1066,7 @@ void CommandLineParser::processArgs()
 	parseCombinedJsonOption();
 
 	if (m_args.count(g_strOutputDir))
-		m_options.output.dir = m_args.at(g_strOutputDir).as<string>();
+		m_options.output.dir = m_args.at(g_strOutputDir).as<std::string>();
 
 	m_options.output.overwriteFiles = (m_args.count(g_strOverwrite) > 0);
 
@@ -1086,14 +1085,14 @@ void CommandLineParser::processArgs()
 	m_options.compiler.estimateGas = (m_args.count(g_strGas) > 0);
 
 	if (m_args.count(g_strBasePath))
-		m_options.input.basePath = m_args[g_strBasePath].as<string>();
+		m_options.input.basePath = m_args[g_strBasePath].as<std::string>();
 
 	if (m_args.count(g_strIncludePath) > 0)
 	{
 		if (m_options.input.basePath.empty())
 			solThrow(CommandLineValidationError, "--" + g_strIncludePath + " option requires a non-empty base path.");
 
-		for (string const& includePath: m_args[g_strIncludePath].as<vector<string>>())
+		for (std::string const& includePath: m_args[g_strIncludePath].as<std::vector<std::string>>())
 		{
 			if (includePath.empty())
 				solThrow(CommandLineValidationError, "Empty values are not allowed in --" + g_strIncludePath + ".");
@@ -1104,15 +1103,15 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strAllowPaths))
 	{
-		vector<string> paths;
-		for (string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<string>(), boost::is_any_of(",")))
+		std::vector<std::string> paths;
+		for (std::string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<std::string>(), boost::is_any_of(",")))
 			if (!allowedPath.empty())
 				m_options.input.allowedDirectories.insert(allowedPath);
 	}
 
 	if (m_args.count(g_strStopAfter))
 	{
-		if (m_args[g_strStopAfter].as<string>() != "parsing")
+		if (m_args[g_strStopAfter].as<std::string>() != "parsing")
 			solThrow(CommandLineValidationError, "Valid options for --" + g_strStopAfter + " are: \"parsing\".\n");
 		else
 			m_options.output.stopAfter = CompilerStack::State::Parsed;
@@ -1124,7 +1123,7 @@ void CommandLineParser::processArgs()
 		return;
 
 	if (m_args.count(g_strLibraries))
-		for (string const& library: m_args[g_strLibraries].as<vector<string>>())
+		for (std::string const& library: m_args[g_strLibraries].as<std::vector<std::string>>())
 			parseLibraryOption(library);
 
 	if (m_options.input.mode == InputMode::Linker)
@@ -1132,8 +1131,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strEVMVersion))
 	{
-		string versionOptionStr = m_args[g_strEVMVersion].as<string>();
-		optional<langutil::EVMVersion> versionOption = langutil::EVMVersion::fromString(versionOptionStr);
+		std::string versionOptionStr = m_args[g_strEVMVersion].as<std::string>();
+		std::optional<langutil::EVMVersion> versionOption = langutil::EVMVersion::fromString(versionOptionStr);
 		if (!versionOption)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strEVMVersion + ": " + versionOptionStr);
 		m_options.output.evmVersion = *versionOption;
@@ -1144,7 +1143,7 @@ void CommandLineParser::processArgs()
 		// Request as uint64_t, since uint8_t will be parsed as character by boost.
 		uint64_t versionOption = m_args[g_strEOFVersion].as<uint64_t>();
 		if (versionOption != 1)
-			solThrow(CommandLineValidationError, "Invalid option for --" + g_strEOFVersion + ": " + to_string(versionOption));
+			solThrow(CommandLineValidationError, "Invalid option for --" + g_strEOFVersion + ": " + std::to_string(versionOption));
 		m_options.output.eofVersion = 1;
 	}
 
@@ -1170,7 +1169,7 @@ void CommandLineParser::processArgs()
 
 		try
 		{
-			yul::OptimiserSuite::validateSequence(m_args[g_strYulOptimizations].as<string>());
+			yul::OptimiserSuite::validateSequence(m_args[g_strYulOptimizations].as<std::string>());
 		}
 		catch (yul::OptimizerException const& _exception)
 		{
@@ -1180,12 +1179,12 @@ void CommandLineParser::processArgs()
 			);
 		}
 
-		m_options.optimizer.yulSteps = m_args[g_strYulOptimizations].as<string>();
+		m_options.optimizer.yulSteps = m_args[g_strYulOptimizations].as<std::string>();
 	}
 
 	if (m_options.input.mode == InputMode::Assembler)
 	{
-		vector<string> const nonAssemblyModeOptions = {
+		std::vector<std::string> const nonAssemblyModeOptions = {
 			// TODO: The list is not complete. Add more.
 			g_strOutputDir,
 			g_strGas,
@@ -1193,10 +1192,10 @@ void CommandLineParser::processArgs()
 		};
 		if (countEnabledOptions(nonAssemblyModeOptions) >= 1)
 		{
-			auto optionEnabled = [&](string const& name){ return m_args.count(name) > 0; };
+			auto optionEnabled = [&](std::string const& name){ return m_args.count(name) > 0; };
 			auto enabledOptions = nonAssemblyModeOptions | ranges::views::filter(optionEnabled) | ranges::to_vector;
 
-			string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
+			std::string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
 			solThrow(CommandLineValidationError, message);
 		}
 
@@ -1207,7 +1206,7 @@ void CommandLineParser::processArgs()
 
 		if (m_args.count(g_strMachine))
 		{
-			string machine = m_args[g_strMachine].as<string>();
+			std::string machine = m_args[g_strMachine].as<std::string>();
 			if (machine == g_strEVM)
 				m_options.assembly.targetMachine = Machine::EVM;
 			else
@@ -1215,7 +1214,7 @@ void CommandLineParser::processArgs()
 		}
 		if (m_args.count(g_strYulDialect))
 		{
-			string dialect = m_args[g_strYulDialect].as<string>();
+			std::string dialect = m_args[g_strYulDialect].as<std::string>();
 			if (dialect == g_strEVM)
 				m_options.assembly.inputLanguage = Input::StrictAssembly;
 			else
@@ -1239,7 +1238,7 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strMetadataHash))
 	{
-		string hashStr = m_args[g_strMetadataHash].as<string>();
+		std::string hashStr = m_args[g_strMetadataHash].as<std::string>();
 		if (hashStr == g_strIPFS)
 			m_options.metadata.hash = CompilerStack::MetadataHash::IPFS;
 		else if (hashStr == g_strSwarm)
@@ -1267,8 +1266,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerContracts))
 	{
-		string contractsStr = m_args[g_strModelCheckerContracts].as<string>();
-		optional<ModelCheckerContracts> contracts = ModelCheckerContracts::fromString(contractsStr);
+		std::string contractsStr = m_args[g_strModelCheckerContracts].as<std::string>();
+		std::optional<ModelCheckerContracts> contracts = ModelCheckerContracts::fromString(contractsStr);
 		if (!contracts)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerContracts + ": " + contractsStr);
 		m_options.modelChecker.settings.contracts = std::move(*contracts);
@@ -1279,8 +1278,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerEngine))
 	{
-		string engineStr = m_args[g_strModelCheckerEngine].as<string>();
-		optional<ModelCheckerEngine> engine = ModelCheckerEngine::fromString(engineStr);
+		std::string engineStr = m_args[g_strModelCheckerEngine].as<std::string>();
+		std::optional<ModelCheckerEngine> engine = ModelCheckerEngine::fromString(engineStr);
 		if (!engine)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerEngine + ": " + engineStr);
 		m_options.modelChecker.settings.engine = *engine;
@@ -1288,8 +1287,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerExtCalls))
 	{
-		string mode = m_args[g_strModelCheckerExtCalls].as<string>();
-		optional<ModelCheckerExtCalls> extCallsMode = ModelCheckerExtCalls::fromString(mode);
+		std::string mode = m_args[g_strModelCheckerExtCalls].as<std::string>();
+		std::optional<ModelCheckerExtCalls> extCallsMode = ModelCheckerExtCalls::fromString(mode);
 		if (!extCallsMode)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerExtCalls + ": " + mode);
 		m_options.modelChecker.settings.externalCalls = *extCallsMode;
@@ -1297,8 +1296,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerInvariants))
 	{
-		string invsStr = m_args[g_strModelCheckerInvariants].as<string>();
-		optional<ModelCheckerInvariants> invs = ModelCheckerInvariants::fromString(invsStr);
+		std::string invsStr = m_args[g_strModelCheckerInvariants].as<std::string>();
+		std::optional<ModelCheckerInvariants> invs = ModelCheckerInvariants::fromString(invsStr);
 		if (!invs)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerInvariants + ": " + invsStr);
 		m_options.modelChecker.settings.invariants = *invs;
@@ -1315,8 +1314,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerSolvers))
 	{
-		string solversStr = m_args[g_strModelCheckerSolvers].as<string>();
-		optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
+		std::string solversStr = m_args[g_strModelCheckerSolvers].as<std::string>();
+		std::optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
 		if (!solvers)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerSolvers + ": " + solversStr);
 		m_options.modelChecker.settings.solvers = *solvers;
@@ -1331,8 +1330,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerTargets))
 	{
-		string targetsStr = m_args[g_strModelCheckerTargets].as<string>();
-		optional<ModelCheckerTargets> targets = ModelCheckerTargets::fromString(targetsStr);
+		std::string targetsStr = m_args[g_strModelCheckerTargets].as<std::string>();
+		std::optional<ModelCheckerTargets> targets = ModelCheckerTargets::fromString(targetsStr);
 		if (!targets)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerTargets + ": " + targetsStr);
 		m_options.modelChecker.settings.targets = *targets;
@@ -1371,8 +1370,8 @@ void CommandLineParser::parseCombinedJsonOption()
 	if (!m_args.count(g_strCombinedJson))
 		return;
 
-	set<string> requests;
-	for (string const& item: boost::split(requests, m_args[g_strCombinedJson].as<string>(), boost::is_any_of(",")))
+	std::set<std::string> requests;
+	for (std::string const& item: boost::split(requests, m_args[g_strCombinedJson].as<std::string>(), boost::is_any_of(",")))
 		if (CombinedJsonRequests::componentMap().count(item) == 0)
 			solThrow(CommandLineValidationError, "Invalid option to --" + g_strCombinedJson + ": " + item);
 
@@ -1381,19 +1380,19 @@ void CommandLineParser::parseCombinedJsonOption()
 		m_options.compiler.combinedJsonRequests.value().*component = (requests.count(componentName) > 0);
 }
 
-size_t CommandLineParser::countEnabledOptions(vector<string> const& _optionNames) const
+size_t CommandLineParser::countEnabledOptions(std::vector<std::string> const& _optionNames) const
 {
 	size_t count = 0;
-	for (string const& _option: _optionNames)
+	for (std::string const& _option: _optionNames)
 		count += m_args.count(_option);
 
 	return count;
 }
 
-string CommandLineParser::joinOptionNames(vector<string> const& _optionNames, string _separator)
+std::string CommandLineParser::joinOptionNames(std::vector<std::string> const& _optionNames, std::string _separator)
 {
 	return util::joinHumanReadable(
-		_optionNames | ranges::views::transform([](string const& _option){ return "--" + _option; }),
+		_optionNames | ranges::views::transform([](std::string const& _option){ return "--" + _option; }),
 		_separator
 	);
 }
diff --git a/solc/main.cpp b/solc/main.cpp
index a6fa5015b..4237f9ac6 100644
--- a/solc/main.cpp
+++ b/solc/main.cpp
@@ -29,7 +29,6 @@
 
 #include <iostream>
 
-using namespace std;
 using namespace solidity;
 
 
@@ -37,31 +36,31 @@ int main(int argc, char** argv)
 {
 	try
 	{
-		solidity::frontend::CommandLineInterface cli(cin, cout, cerr);
+		solidity::frontend::CommandLineInterface cli(std::cin, std::cout, std::cerr);
 		return cli.run(argc, argv) ? 0 : 1;
 	}
 	catch (smtutil::SMTLogicError const& _exception)
 	{
-		cerr << "SMT logic error:" << endl;
-		cerr << boost::diagnostic_information(_exception);
+		std::cerr << "SMT logic error:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
 		return 2;
 	}
 	catch (langutil::UnimplementedFeatureError const& _exception)
 	{
-		cerr << "Unimplemented feature:" << endl;
-		cerr << boost::diagnostic_information(_exception);
+		std::cerr << "Unimplemented feature:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
 		return 2;
 	}
 	catch (langutil::InternalCompilerError const& _exception)
 	{
-		cerr << "Internal compiler error:" << endl;
-		cerr << boost::diagnostic_information(_exception);
+		std::cerr << "Internal compiler error:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
 		return 2;
 	}
 	catch (...)
 	{
-		cerr << "Uncaught exception:" << endl;
-		cerr << boost::current_exception_diagnostic_information() << endl;
+		std::cerr << "Uncaught exception:" << std::endl;
+		std::cerr << boost::current_exception_diagnostic_information() << std::endl;
 		return 2;
 	}
 }