diff --git a/.editorconfig b/.editorconfig
index d9a0ca8..bc8cb12 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -55,6 +55,8 @@ csharp_style_inlined_variable_declaration = true:suggestion
 csharp_style_throw_expression = false:none
 csharp_style_conditional_delegate_call = true:suggestion
 
+csharp_style_namespace_declarations = file_scoped:warning
+
 # utf8 strings only clarify if it really is a string. in the case of binary data, it only obfuscates things.
 csharp_style_prefer_utf8_string_literals = false:none
 
diff --git a/src/MethodCheck.Core/BinaryProcessor.cs b/src/MethodCheck.Core/BinaryProcessor.cs
index d683a03..3097d13 100644
--- a/src/MethodCheck.Core/BinaryProcessor.cs
+++ b/src/MethodCheck.Core/BinaryProcessor.cs
@@ -2,138 +2,137 @@
 using System;
 using System.Collections.Generic;
 
-namespace MethodCheck.Core
+namespace MethodCheck.Core;
+
+public static class BinaryProcessor
 {
-	public static class BinaryProcessor
+	public static byte[]? Parse(ReadOnlySpan<char> text)
 	{
-		public static byte[]? Parse(ReadOnlySpan<char> text)
+		var index = 0;
+		var buffer = new List<byte>();
+		var halfByte = false;
+		var readingComment = false;
+		byte tmp = 0;
+
+		while (index < text.Length)
 		{
-			var index = 0;
-			var buffer = new List<byte>();
-			var halfByte = false;
-			var readingComment = false;
-			byte tmp = 0;
+			var c = text[index++];
+			byte x;
 
-			while (index < text.Length)
+			if (c == '\r' || c == '\n')
 			{
-				var c = text[index++];
-				byte x;
+				readingComment = false;
+				continue;
+			}
 
-				if (c == '\r' || c == '\n')
-				{
-					readingComment = false;
-					continue;
-				}
+			if (char.IsWhiteSpace(c) || readingComment)
+			{
+				continue;
+			}
 
-				if (char.IsWhiteSpace(c) || readingComment)
-				{
-					continue;
-				}
+			if ((uint)(c - '0') <= 9)
+			{
+				x = unchecked((byte)(c - '0'));
+			}
+			else
+			{
+				c |= '\x20';
 
-				if ((uint)(c - '0') <= 9)
+				if ((uint)(c - 'a') <= 5)
 				{
-					x = unchecked((byte)(c - '0'));
+					x = unchecked((byte)(c - 'a' + 10));
 				}
-				else
+				else if (c == '/' && index < text.Length && text[index] == '/')
 				{
-					c |= '\x20';
-
-					if ((uint)(c - 'a') <= 5)
-					{
-						x = unchecked((byte)(c - 'a' + 10));
-					}
-					else if (c == '/' && index < text.Length && text[index] == '/')
-					{
-						readingComment = true;
-						index++;
-						continue;
-					}
-					else
-					{
-						return null;
-					}
-				}
-
-				if (halfByte)
-				{
-					buffer.Add(unchecked((byte)(tmp | x)));
-					halfByte = false;
+					readingComment = true;
+					index++;
+					continue;
 				}
 				else
 				{
-					tmp = unchecked((byte)(x << 4));
-					halfByte = true;
+					return null;
 				}
 			}
 
 			if (halfByte)
 			{
-				buffer.Add(tmp);
+				buffer.Add(unchecked((byte)(tmp | x)));
+				halfByte = false;
+			}
+			else
+			{
+				tmp = unchecked((byte)(x << 4));
+				halfByte = true;
 			}
+		}
 
-			return buffer.ToArray();
+		if (halfByte)
+		{
+			buffer.Add(tmp);
 		}
 
-		public static string Format(ReadOnlySpan<byte> blob)
+		return buffer.ToArray();
+	}
+
+	public static string Format(ReadOnlySpan<byte> blob)
+	{
+		if (blob.Length == 0)
 		{
-			if (blob.Length == 0)
-			{
-				return string.Empty;
-			}
+			return string.Empty;
+		}
 
-			// 2 characters per byte +
-			// one separator character per byte after the first +
-			// one additional separator character every 4 bytes after the first.
-			//
-			// After every 16 bytes, the separator will be a newline, otherwise it will be spaces.
-			var length = 2 + (((blob.Length - 1) * 13) >> 2);
+		// 2 characters per byte +
+		// one separator character per byte after the first +
+		// one additional separator character every 4 bytes after the first.
+		//
+		// After every 16 bytes, the separator will be a newline, otherwise it will be spaces.
+		var length = 2 + (((blob.Length - 1) * 13) >> 2);
 
-			if (Environment.NewLine.Length != 2)
-			{
-				// We calculated length based on Environment.NewLine being 2 characters.
-				// We need to adjust if it wasn't for some reason.
-				length += (Environment.NewLine.Length - 2) * ((blob.Length - 1) >> 4);
-			}
+		if (Environment.NewLine.Length != 2)
+		{
+			// We calculated length based on Environment.NewLine being 2 characters.
+			// We need to adjust if it wasn't for some reason.
+			length += (Environment.NewLine.Length - 2) * ((blob.Length - 1) >> 4);
+		}
 
-			return string.Create(
-				length,
-				blob,
-				static (target, blob) =>
-				{
-					var write = 0;
-					var nl = Environment.NewLine.AsSpan();
+		return string.Create(
+			length,
+			blob,
+			static (target, blob) =>
+			{
+				var write = 0;
+				var nl = Environment.NewLine.AsSpan();
 
-					WriteByte(target.Slice(write), blob[0]);
-					write += 2;
+				WriteByte(target.Slice(write), blob[0]);
+				write += 2;
 
-					for (var i = 1; i < blob.Length; i++)
+				for (var i = 1; i < blob.Length; i++)
+				{
+					if ((i & 0xF) == 0)
 					{
-						if ((i & 0xF) == 0)
-						{
-							nl.CopyTo(target.Slice(write));
-							write += nl.Length;
-						}
-						else
+						nl.CopyTo(target.Slice(write));
+						write += nl.Length;
+					}
+					else
+					{
+						if ((i & 0x3) == 0)
 						{
-							if ((i & 0x3) == 0)
-							{
-								target[write++] = ' ';
-							}
-
 							target[write++] = ' ';
 						}
 
-						WriteByte(target.Slice(write), blob[i]);
-						write += 2;
+						target[write++] = ' ';
 					}
-				});
 
-			static void WriteByte(Span<char> target, byte b)
-			{
-				const string Alphabet = "0123456789ABCDEF";
-				target[0] = Alphabet[b >> 4];
-				target[1] = Alphabet[b & 0xF];
-			}
+					WriteByte(target.Slice(write), blob[i]);
+					write += 2;
+				}
+			});
+
+		static void WriteByte(Span<char> target, byte b)
+		{
+			const string Alphabet = "0123456789ABCDEF";
+			target[0] = Alphabet[b >> 4];
+			target[1] = Alphabet[b & 0xF];
 		}
 	}
 }
diff --git a/src/MethodCheck.Core/Data/ExceptionHandler.cs b/src/MethodCheck.Core/Data/ExceptionHandler.cs
index 5903843..fff84f1 100644
--- a/src/MethodCheck.Core/Data/ExceptionHandler.cs
+++ b/src/MethodCheck.Core/Data/ExceptionHandler.cs
@@ -1,17 +1,16 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Reflection;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class ExceptionHandler(
+	ExceptionHandlingClauseOptions type,
+	ILRange tryRange,
+	ILRange handlerRange,
+	int filterOrType)
 {
-	public sealed class ExceptionHandler(
-		ExceptionHandlingClauseOptions type,
-		ILRange tryRange,
-		ILRange handlerRange,
-		int filterOrType)
-	{
-		public ExceptionHandlingClauseOptions Type { get; } = type;
-		public ILRange TryRange { get; } = tryRange;
-		public ILRange HandlerRange { get; } = handlerRange;
-		public int FilterOrType { get; } = filterOrType;
-	}
+	public ExceptionHandlingClauseOptions Type { get; } = type;
+	public ILRange TryRange { get; } = tryRange;
+	public ILRange HandlerRange { get; } = handlerRange;
+	public int FilterOrType { get; } = filterOrType;
 }
diff --git a/src/MethodCheck.Core/Data/Instruction.cs b/src/MethodCheck.Core/Data/Instruction.cs
index 1409f8f..a85389c 100644
--- a/src/MethodCheck.Core/Data/Instruction.cs
+++ b/src/MethodCheck.Core/Data/Instruction.cs
@@ -1,41 +1,40 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Reflection.Emit;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class Instruction
 {
-	public sealed class Instruction
+	public const int MaxMnemonicLength = 14;
+
+	public Instruction(ILRange range, OpCode opcode, object? argument)
 	{
-		public const int MaxMnemonicLength = 14;
+		Kind = InstructionKind.OpCode;
+		Range = range;
+		OpCode = opcode;
+		Argument = argument;
+	}
 
-		public Instruction(ILRange range, OpCode opcode, object? argument)
-		{
-			Kind = InstructionKind.OpCode;
-			Range = range;
-			OpCode = opcode;
-			Argument = argument;
-		}
+	public Instruction(ILRange range)
+	{
+		Kind = InstructionKind.Invalid;
+		Range = range;
+	}
+
+	public InstructionKind Kind { get; }
+	public ILRange Range { get; }
+	public OpCode OpCode { get; }
+	public object? Argument { get; }
 
-		public Instruction(ILRange range)
+	public override string ToString()
+	{
+		if (Argument == null)
 		{
-			Kind = InstructionKind.Invalid;
-			Range = range;
+			return Range.Offset + ": " + OpCode.Name;
 		}
-
-		public InstructionKind Kind { get; }
-		public ILRange Range { get; }
-		public OpCode OpCode { get; }
-		public object? Argument { get; }
-
-		public override string ToString()
+		else
 		{
-			if (Argument == null)
-			{
-				return Range.Offset + ": " + OpCode.Name;
-			}
-			else
-			{
-				return Range.Offset + ": " + OpCode.Name + " " + Argument;
-			}
+			return Range.Offset + ": " + OpCode.Name + " " + Argument;
 		}
 	}
 }
diff --git a/src/MethodCheck.Core/Data/InstructionKind.cs b/src/MethodCheck.Core/Data/InstructionKind.cs
index c20c856..6152856 100644
--- a/src/MethodCheck.Core/Data/InstructionKind.cs
+++ b/src/MethodCheck.Core/Data/InstructionKind.cs
@@ -1,9 +1,8 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public enum InstructionKind
 {
-	public enum InstructionKind
-	{
-		Invalid,
-		OpCode,
-	}
+	Invalid,
+	OpCode,
 }
diff --git a/src/MethodCheck.Core/Data/MethodData.cs b/src/MethodCheck.Core/Data/MethodData.cs
index b584fa8..d436260 100644
--- a/src/MethodCheck.Core/Data/MethodData.cs
+++ b/src/MethodCheck.Core/Data/MethodData.cs
@@ -1,21 +1,20 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Collections.Immutable;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class MethodData(
+	MetadataToken localsToken,
+	int maxStack,
+	int codeSize,
+	MethodDataFlags flags,
+	ImmutableArray<Instruction> instructions,
+	ImmutableArray<MethodDataSection> dataSections)
 {
-	public sealed class MethodData(
-		MetadataToken localsToken,
-		int maxStack,
-		int codeSize,
-		MethodDataFlags flags,
-		ImmutableArray<Instruction> instructions,
-		ImmutableArray<MethodDataSection> dataSections)
-	{
-		public MetadataToken LocalsToken { get; } = localsToken;
-		public int MaxStack { get; } = maxStack;
-		public int CodeSize { get; } = codeSize;
-		public MethodDataFlags Flags { get; } = flags;
-		public ImmutableArray<Instruction> Instructions { get; } = instructions;
-		public ImmutableArray<MethodDataSection> DataSections { get; } = dataSections;
-	}
+	public MetadataToken LocalsToken { get; } = localsToken;
+	public int MaxStack { get; } = maxStack;
+	public int CodeSize { get; } = codeSize;
+	public MethodDataFlags Flags { get; } = flags;
+	public ImmutableArray<Instruction> Instructions { get; } = instructions;
+	public ImmutableArray<MethodDataSection> DataSections { get; } = dataSections;
 }
diff --git a/src/MethodCheck.Core/Data/MethodDataFlags.cs b/src/MethodCheck.Core/Data/MethodDataFlags.cs
index cdfa98f..a15b0d1 100644
--- a/src/MethodCheck.Core/Data/MethodDataFlags.cs
+++ b/src/MethodCheck.Core/Data/MethodDataFlags.cs
@@ -1,14 +1,14 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System;
 
-namespace MethodCheck.Core.Data
-{
+namespace MethodCheck.Core.Data;
+
 #pragma warning disable CA1711 // Identifiers should not have incorrect suffix
-	[Flags]
-	public enum MethodDataFlags
-	{
-		None = 0,
-		InitFields = 1 << 0,
-	}
-#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
+[Flags]
+public enum MethodDataFlags
+{
+	None = 0,
+	InitFields = 1 << 0,
 }
+#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
+
diff --git a/src/MethodCheck.Core/Data/MethodDataSection.cs b/src/MethodCheck.Core/Data/MethodDataSection.cs
index a3e0d1a..87e1313 100644
--- a/src/MethodCheck.Core/Data/MethodDataSection.cs
+++ b/src/MethodCheck.Core/Data/MethodDataSection.cs
@@ -1,10 +1,9 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Collections.Immutable;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class MethodDataSection(ImmutableArray<ExceptionHandler> exceptionHandlers)
 {
-	public sealed class MethodDataSection(ImmutableArray<ExceptionHandler> exceptionHandlers)
-	{
-		public ImmutableArray<ExceptionHandler> ExceptionHandlers { get; } = exceptionHandlers;
-	}
+	public ImmutableArray<ExceptionHandler> ExceptionHandlers { get; } = exceptionHandlers;
 }
diff --git a/src/MethodCheck.Core/Data/Sections/BaseSection.cs b/src/MethodCheck.Core/Data/Sections/BaseSection.cs
index bf907cf..83faf54 100644
--- a/src/MethodCheck.Core/Data/Sections/BaseSection.cs
+++ b/src/MethodCheck.Core/Data/Sections/BaseSection.cs
@@ -1,8 +1,7 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public abstract class BaseSection(ILRange range)
 {
-	public abstract class BaseSection(ILRange range)
-	{
-		public ILRange Range { get; } = range;
-	}
+	public ILRange Range { get; } = range;
 }
diff --git a/src/MethodCheck.Core/Data/Sections/CannotGenerateSectionException.cs b/src/MethodCheck.Core/Data/Sections/CannotGenerateSectionException.cs
index 0c1017b..df7d253 100644
--- a/src/MethodCheck.Core/Data/Sections/CannotGenerateSectionException.cs
+++ b/src/MethodCheck.Core/Data/Sections/CannotGenerateSectionException.cs
@@ -1,22 +1,21 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System;
 
-namespace MethodCheck.Core.Data.Sections
+namespace MethodCheck.Core.Data.Sections;
+
+public sealed class CannotGenerateSectionException : Exception
 {
-	public sealed class CannotGenerateSectionException : Exception
+	public CannotGenerateSectionException()
 	{
-		public CannotGenerateSectionException()
-		{
-		}
+	}
 
-		public CannotGenerateSectionException(string message)
-			: base(message)
-		{
-		}
+	public CannotGenerateSectionException(string message)
+		: base(message)
+	{
+	}
 
-		public CannotGenerateSectionException(string message, Exception innerException)
-			: base(message, innerException)
-		{
-		}
+	public CannotGenerateSectionException(string message, Exception innerException)
+		: base(message, innerException)
+	{
 	}
 }
diff --git a/src/MethodCheck.Core/Data/Sections/HandlerBlock.cs b/src/MethodCheck.Core/Data/Sections/HandlerBlock.cs
index 3f529af..ea13d99 100644
--- a/src/MethodCheck.Core/Data/Sections/HandlerBlock.cs
+++ b/src/MethodCheck.Core/Data/Sections/HandlerBlock.cs
@@ -1,27 +1,26 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Reflection;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class HandlerBlock
 {
-	public sealed class HandlerBlock
+	public HandlerBlock(ExceptionHandlingClauseOptions type, MetadataToken exceptionType, BaseSection handlerSection)
 	{
-		public HandlerBlock(ExceptionHandlingClauseOptions type, MetadataToken exceptionType, BaseSection handlerSection)
-		{
-			Type = type;
-			ExceptionType = exceptionType;
-			HandlerSection = handlerSection;
-		}
-
-		public HandlerBlock(ExceptionHandlingClauseOptions type, BaseSection filterSection, BaseSection handlerSection)
-		{
-			Type = type;
-			FilterSection = filterSection;
-			HandlerSection = handlerSection;
-		}
+		Type = type;
+		ExceptionType = exceptionType;
+		HandlerSection = handlerSection;
+	}
 
-		public ExceptionHandlingClauseOptions Type { get; }
-		public BaseSection? FilterSection { get; }
-		public MetadataToken ExceptionType { get; }
-		public BaseSection HandlerSection { get; }
+	public HandlerBlock(ExceptionHandlingClauseOptions type, BaseSection filterSection, BaseSection handlerSection)
+	{
+		Type = type;
+		FilterSection = filterSection;
+		HandlerSection = handlerSection;
 	}
+
+	public ExceptionHandlingClauseOptions Type { get; }
+	public BaseSection? FilterSection { get; }
+	public MetadataToken ExceptionType { get; }
+	public BaseSection HandlerSection { get; }
 }
diff --git a/src/MethodCheck.Core/Data/Sections/ILSection.cs b/src/MethodCheck.Core/Data/Sections/ILSection.cs
index 7ba7cd9..6320207 100644
--- a/src/MethodCheck.Core/Data/Sections/ILSection.cs
+++ b/src/MethodCheck.Core/Data/Sections/ILSection.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class ILSection(ILRange range) : BaseSection(range)
 {
-	public sealed class ILSection(ILRange range) : BaseSection(range)
-	{
-	}
 }
diff --git a/src/MethodCheck.Core/Data/Sections/SectionFactory.cs b/src/MethodCheck.Core/Data/Sections/SectionFactory.cs
index 0dcf1d1..4318c52 100644
--- a/src/MethodCheck.Core/Data/Sections/SectionFactory.cs
+++ b/src/MethodCheck.Core/Data/Sections/SectionFactory.cs
@@ -5,223 +5,222 @@
 using System.Reflection;
 using MethodCheck.Core.Data.Sections;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public static class SectionFactory
 {
-	public static class SectionFactory
+	// Creates a section from the provided values, assuming the handlers are ordered correctly.
+	public static BaseSection Create(ILRange range, IEnumerable<ExceptionHandler> handlers)
 	{
-		// Creates a section from the provided values, assuming the handlers are ordered correctly.
-		public static BaseSection Create(ILRange range, IEnumerable<ExceptionHandler> handlers)
+		ArgumentNullException.ThrowIfNull(handlers);
+
+		var generator = Builder.New();
+
+		foreach (var handler in handlers)
 		{
-			ArgumentNullException.ThrowIfNull(handlers);
+			generator.Add(handler);
+		}
 
-			var generator = Builder.New();
+		var result = generator.CreateSection(range);
+		generator.VerifyEmpty();
+		return result;
+	}
 
-			foreach (var handler in handlers)
-			{
-				generator.Add(handler);
-			}
+	readonly struct Builder
+	{
+		public static Builder New() => new(new List<TryBuilder>());
 
-			var result = generator.CreateSection(range);
-			generator.VerifyEmpty();
-			return result;
+		Builder(List<TryBuilder> pendingTryBlocks)
+		{
+			_pendingTryBlocks = pendingTryBlocks;
 		}
 
-		readonly struct Builder
+		public void Add(ExceptionHandler handler)
 		{
-			public static Builder New() => new(new List<TryBuilder>());
+			var handlerBlock = CreateHandlerBlock(handler);
+			var handlers = FindHandlersMatchingTryBlock(handler.TryRange);
+			handlers.Add(handlerBlock);
+		}
 
-			Builder(List<TryBuilder> pendingTryBlocks)
-			{
-				_pendingTryBlocks = pendingTryBlocks;
-			}
+		public BaseSection CreateSection(ILRange range)
+		{
+			var sections = ExtractSectionsInRange(range);
 
-			public void Add(ExceptionHandler handler)
+			if (sections.Count == 0)
 			{
-				var handlerBlock = CreateHandlerBlock(handler);
-				var handlers = FindHandlersMatchingTryBlock(handler.TryRange);
-				handlers.Add(handlerBlock);
+				return new ILSection(range);
 			}
-
-			public BaseSection CreateSection(ILRange range)
+			else if (sections.Count == 1 && sections[0].Range == range)
 			{
-				var sections = ExtractSectionsInRange(range);
+				return sections[0];
+			}
 
-				if (sections.Count == 0)
-				{
-					return new ILSection(range);
-				}
-				else if (sections.Count == 1 && sections[0].Range == range)
-				{
-					return sections[0];
-				}
+			sections.Sort((x, y) => x.Range.Offset.CompareTo(y.Range.Offset));
+			return CreateSequenceSection(range, sections);
+		}
 
-				sections.Sort((x, y) => x.Range.Offset.CompareTo(y.Range.Offset));
-				return CreateSequenceSection(range, sections);
-			}
+		HandlerBlock CreateHandlerBlock(ExceptionHandler handler)
+		{
+			var handlerSection = CreateSection(handler.HandlerRange);
 
-			HandlerBlock CreateHandlerBlock(ExceptionHandler handler)
+			if (handler.Type == ExceptionHandlingClauseOptions.Filter)
 			{
-				var handlerSection = CreateSection(handler.HandlerRange);
-
-				if (handler.Type == ExceptionHandlingClauseOptions.Filter)
-				{
-					var filterStart = new Label(handler.FilterOrType);
-					var filterRange = new ILRange(filterStart, handler.HandlerRange.Offset - filterStart);
+				var filterStart = new Label(handler.FilterOrType);
+				var filterRange = new ILRange(filterStart, handler.HandlerRange.Offset - filterStart);
 
-					return new HandlerBlock(
-						handler.Type,
-						CreateSection(filterRange),
-						handlerSection);
-				}
-				else
-				{
-					return new HandlerBlock(
-						handler.Type,
-						new MetadataToken(handler.FilterOrType),
-						handlerSection);
-				}
+				return new HandlerBlock(
+					handler.Type,
+					CreateSection(filterRange),
+					handlerSection);
 			}
-
-			static BaseSection CreateSequenceSection(ILRange range, List<BaseSection> sections)
+			else
 			{
-				var builder = ImmutableArray.CreateBuilder<BaseSection>();
-				var offset = range.Offset;
+				return new HandlerBlock(
+					handler.Type,
+					new MetadataToken(handler.FilterOrType),
+					handlerSection);
+			}
+		}
 
-				foreach (var section in sections)
-				{
-					if (section.Range.Offset > offset)
-					{
-						builder.Add(new ILSection(new ILRange(offset, section.Range.Offset - offset)));
-					}
+		static BaseSection CreateSequenceSection(ILRange range, List<BaseSection> sections)
+		{
+			var builder = ImmutableArray.CreateBuilder<BaseSection>();
+			var offset = range.Offset;
 
-					builder.Add(section);
-					offset = End(section.Range);
+			foreach (var section in sections)
+			{
+				if (section.Range.Offset > offset)
+				{
+					builder.Add(new ILSection(new ILRange(offset, section.Range.Offset - offset)));
 				}
 
-				var end = End(range);
+				builder.Add(section);
+				offset = End(section.Range);
+			}
 
-				if (offset < end)
-				{
-					builder.Add(new ILSection(new ILRange(offset, end - offset)));
-				}
+			var end = End(range);
 
-				return new SequenceSection(range, builder.ToImmutable());
+			if (offset < end)
+			{
+				builder.Add(new ILSection(new ILRange(offset, end - offset)));
 			}
 
-			List<BaseSection> ExtractSectionsInRange(ILRange range)
+			return new SequenceSection(range, builder.ToImmutable());
+		}
+
+		List<BaseSection> ExtractSectionsInRange(ILRange range)
+		{
+			var builder = new List<BaseSection>();
+			var write = 0;
+
+			for (var read = 0; read < _pendingTryBlocks.Count; read++)
 			{
-				var builder = new List<BaseSection>();
-				var write = 0;
+				var item = _pendingTryBlocks[read];
 
-				for (var read = 0; read < _pendingTryBlocks.Count; read++)
+				if (range.Contains(item.TryRange))
 				{
-					var item = _pendingTryBlocks[read];
+					var newItem = item.Complete();
 
-					if (range.Contains(item.TryRange))
+					if (!range.Contains(newItem.Range))
 					{
-						var newItem = item.Complete();
+						throw new CannotGenerateSectionException();
+					}
 
-						if (!range.Contains(newItem.Range))
+					foreach (var other in builder)
+					{
+						if (newItem.Range.Overlaps(other.Range))
 						{
 							throw new CannotGenerateSectionException();
 						}
-
-						foreach (var other in builder)
-						{
-							if (newItem.Range.Overlaps(other.Range))
-							{
-								throw new CannotGenerateSectionException();
-							}
-						}
-
-						builder.Add(newItem);
 					}
-					else
-					{
-						if (write != read)
-						{
-							_pendingTryBlocks[write] = item;
-						}
 
-						write++;
-					}
+					builder.Add(newItem);
 				}
-
-				_pendingTryBlocks.RemoveRange(write, _pendingTryBlocks.Count - write);
-				return builder;
-			}
-
-			ImmutableArray<HandlerBlock>.Builder FindHandlersMatchingTryBlock(ILRange range)
-			{
-				foreach (var item in _pendingTryBlocks)
+				else
 				{
-					if (item.TryRange == range)
+					if (write != read)
 					{
-						return item.Handlers;
+						_pendingTryBlocks[write] = item;
 					}
-				}
 
-				var builder = new TryBuilder(range, CreateSection(range));
-				_pendingTryBlocks.Add(builder);
-				return builder.Handlers;
+					write++;
+				}
 			}
 
-			static Label End(ILRange range) => range.Offset + range.Length;
+			_pendingTryBlocks.RemoveRange(write, _pendingTryBlocks.Count - write);
+			return builder;
+		}
 
-			public void VerifyEmpty()
+		ImmutableArray<HandlerBlock>.Builder FindHandlersMatchingTryBlock(ILRange range)
+		{
+			foreach (var item in _pendingTryBlocks)
 			{
-				if (_pendingTryBlocks.Count > 0)
+				if (item.TryRange == range)
 				{
-					throw new CannotGenerateSectionException();
+					return item.Handlers;
 				}
 			}
 
-			readonly List<TryBuilder> _pendingTryBlocks;
+			var builder = new TryBuilder(range, CreateSection(range));
+			_pendingTryBlocks.Add(builder);
+			return builder.Handlers;
+		}
 
-			readonly struct TryBuilder(ILRange tryRange, BaseSection trySection)
-			{
-				public ILRange TryRange { get; } = tryRange;
-				public BaseSection TrySection { get; } = trySection;
-				public ImmutableArray<HandlerBlock>.Builder Handlers { get; } = ImmutableArray.CreateBuilder<HandlerBlock>();
+		static Label End(ILRange range) => range.Offset + range.Length;
 
-				public TryBlockSection Complete()
-				{
-					var handlers = Handlers.ToImmutable();
-					handlers.Sort((x, y) => x.HandlerSection.Range.Offset.CompareTo(y.HandlerSection.Range.Offset));
+		public void VerifyEmpty()
+		{
+			if (_pendingTryBlocks.Count > 0)
+			{
+				throw new CannotGenerateSectionException();
+			}
+		}
 
-					var end = End(TrySection.Range);
+		readonly List<TryBuilder> _pendingTryBlocks;
 
-					foreach (var handler in handlers)
-					{
-						var handlerEnd = End(handler.HandlerSection.Range);
+		readonly struct TryBuilder(ILRange tryRange, BaseSection trySection)
+		{
+			public ILRange TryRange { get; } = tryRange;
+			public BaseSection TrySection { get; } = trySection;
+			public ImmutableArray<HandlerBlock>.Builder Handlers { get; } = ImmutableArray.CreateBuilder<HandlerBlock>();
 
-						if (handler.FilterSection != null)
-						{
-							var filterRange = handler.FilterSection.Range;
+			public TryBlockSection Complete()
+			{
+				var handlers = Handlers.ToImmutable();
+				handlers.Sort((x, y) => x.HandlerSection.Range.Offset.CompareTo(y.HandlerSection.Range.Offset));
 
-							if (filterRange.Offset != end)
-							{
-								throw new CannotGenerateSectionException();
-							}
+				var end = End(TrySection.Range);
 
-							end = End(filterRange);
-						}
+				foreach (var handler in handlers)
+				{
+					var handlerEnd = End(handler.HandlerSection.Range);
 
-						var handlerRange = handler.HandlerSection.Range;
+					if (handler.FilterSection != null)
+					{
+						var filterRange = handler.FilterSection.Range;
 
-						if (handlerRange.Offset != end)
+						if (filterRange.Offset != end)
 						{
 							throw new CannotGenerateSectionException();
 						}
 
-						end = End(handlerRange);
+						end = End(filterRange);
 					}
 
-					return new TryBlockSection(
-						new ILRange(TryRange.Offset, end - TryRange.Offset),
-						TrySection,
-						handlers);
+					var handlerRange = handler.HandlerSection.Range;
+
+					if (handlerRange.Offset != end)
+					{
+						throw new CannotGenerateSectionException();
+					}
+
+					end = End(handlerRange);
 				}
+
+				return new TryBlockSection(
+					new ILRange(TryRange.Offset, end - TryRange.Offset),
+					TrySection,
+					handlers);
 			}
 		}
 	}
diff --git a/src/MethodCheck.Core/Data/Sections/SequenceSection.cs b/src/MethodCheck.Core/Data/Sections/SequenceSection.cs
index 5922801..6c09ae0 100644
--- a/src/MethodCheck.Core/Data/Sections/SequenceSection.cs
+++ b/src/MethodCheck.Core/Data/Sections/SequenceSection.cs
@@ -1,10 +1,9 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Collections.Immutable;
 
-namespace MethodCheck.Core.Data.Sections
+namespace MethodCheck.Core.Data.Sections;
+
+public sealed class SequenceSection(ILRange range, ImmutableArray<BaseSection> sections) : BaseSection(range)
 {
-	public sealed class SequenceSection(ILRange range, ImmutableArray<BaseSection> sections) : BaseSection(range)
-	{
-		public ImmutableArray<BaseSection> Sections { get; } = sections;
-	}
+	public ImmutableArray<BaseSection> Sections { get; } = sections;
 }
diff --git a/src/MethodCheck.Core/Data/Sections/TryBlockSection.cs b/src/MethodCheck.Core/Data/Sections/TryBlockSection.cs
index 1407771..3436199 100644
--- a/src/MethodCheck.Core/Data/Sections/TryBlockSection.cs
+++ b/src/MethodCheck.Core/Data/Sections/TryBlockSection.cs
@@ -1,15 +1,14 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Collections.Immutable;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public sealed class TryBlockSection(
+	ILRange range,
+	BaseSection tryBlock,
+	ImmutableArray<HandlerBlock> handlerBlocks)
+	: BaseSection(range)
 {
-	public sealed class TryBlockSection(
-		ILRange range,
-		BaseSection tryBlock,
-		ImmutableArray<HandlerBlock> handlerBlocks)
-		: BaseSection(range)
-	{
-		public BaseSection TryBlock { get; } = tryBlock;
-		public ImmutableArray<HandlerBlock> HandlerBlocks { get; } = handlerBlocks;
-	}
+	public BaseSection TryBlock { get; } = tryBlock;
+	public ImmutableArray<HandlerBlock> HandlerBlocks { get; } = handlerBlocks;
 }
diff --git a/src/MethodCheck.Core/Data/Values/ILRange.cs b/src/MethodCheck.Core/Data/Values/ILRange.cs
index 0a05e18..24a533f 100644
--- a/src/MethodCheck.Core/Data/Values/ILRange.cs
+++ b/src/MethodCheck.Core/Data/Values/ILRange.cs
@@ -1,30 +1,29 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public readonly struct ILRange(Label offset, int length) : IEquatable<ILRange>
 {
-	public readonly struct ILRange(Label offset, int length) : IEquatable<ILRange>
-	{
-		public Label Offset { get; } = offset;
-		public int Length { get; } = length;
+	public Label Offset { get; } = offset;
+	public int Length { get; } = length;
 
-		public override int GetHashCode()
+	public override int GetHashCode()
+	{
+		unchecked
 		{
-			unchecked
-			{
-				var tmp = (uint)Offset.GetHashCode();
-				tmp = ((tmp << 16) | (tmp >> 16)) ^ (uint)Length;
-				return (int)tmp;
-			}
+			var tmp = (uint)Offset.GetHashCode();
+			tmp = ((tmp << 16) | (tmp >> 16)) ^ (uint)Length;
+			return (int)tmp;
 		}
+	}
 
-		public override bool Equals(object? obj) => obj is ILRange range && Equals(range);
-		public bool Equals(ILRange other) => Offset == other.Offset && Length == other.Length;
-		public bool Contains(ILRange range) => range.Offset >= Offset && (range.Offset + range.Length - Offset) <= Length;
-		public bool Overlaps(ILRange range) => range.Offset < Offset + Length && Offset < range.Offset + range.Length;
-		public override string ToString() => $"{Offset} ({Length})";
+	public override bool Equals(object? obj) => obj is ILRange range && Equals(range);
+	public bool Equals(ILRange other) => Offset == other.Offset && Length == other.Length;
+	public bool Contains(ILRange range) => range.Offset >= Offset && (range.Offset + range.Length - Offset) <= Length;
+	public bool Overlaps(ILRange range) => range.Offset < Offset + Length && Offset < range.Offset + range.Length;
+	public override string ToString() => $"{Offset} ({Length})";
 
-		public static bool operator ==(ILRange range1, ILRange range2) => range1.Equals(range2);
-		public static bool operator !=(ILRange range1, ILRange range2) => !range1.Equals(range2);
-	}
+	public static bool operator ==(ILRange range1, ILRange range2) => range1.Equals(range2);
+	public static bool operator !=(ILRange range1, ILRange range2) => !range1.Equals(range2);
 }
diff --git a/src/MethodCheck.Core/Data/Values/IncompleteArgument.cs b/src/MethodCheck.Core/Data/Values/IncompleteArgument.cs
index dc22623..0549099 100644
--- a/src/MethodCheck.Core/Data/Values/IncompleteArgument.cs
+++ b/src/MethodCheck.Core/Data/Values/IncompleteArgument.cs
@@ -1,14 +1,13 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
-namespace MethodCheck.Core.Data
-{
-	sealed class IncompleteArgument
-	{
-		public static IncompleteArgument Value { get; } = new IncompleteArgument();
+namespace MethodCheck.Core.Data;
 
-		IncompleteArgument()
-		{
-		}
+sealed class IncompleteArgument
+{
+	public static IncompleteArgument Value { get; } = new IncompleteArgument();
 
-		public override string ToString() => "??";
+	IncompleteArgument()
+	{
 	}
+
+	public override string ToString() => "??";
 }
diff --git a/src/MethodCheck.Core/Data/Values/Label.cs b/src/MethodCheck.Core/Data/Values/Label.cs
index fbd7673..fd3ec9f 100644
--- a/src/MethodCheck.Core/Data/Values/Label.cs
+++ b/src/MethodCheck.Core/Data/Values/Label.cs
@@ -3,29 +3,28 @@
 using System.Diagnostics;
 using System.Globalization;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public readonly struct Label(int offset) : IEquatable<Label>, IComparable<Label>
 {
-	public readonly struct Label(int offset) : IEquatable<Label>, IComparable<Label>
-	{
-		public override bool Equals(object? obj) => obj is Label label && Equals(label);
-		public bool Equals(Label other) => _offset == other._offset;
-		public int CompareTo(Label other) => _offset.CompareTo(other._offset);
-		public override int GetHashCode() => _offset;
-		public override string ToString() => "IL_" + _offset.ToString("X4", CultureInfo.InvariantCulture);
+	public override bool Equals(object? obj) => obj is Label label && Equals(label);
+	public bool Equals(Label other) => _offset == other._offset;
+	public int CompareTo(Label other) => _offset.CompareTo(other._offset);
+	public override int GetHashCode() => _offset;
+	public override string ToString() => "IL_" + _offset.ToString("X4", CultureInfo.InvariantCulture);
 
-		public static explicit operator int(Label label) => label._offset;
-		public static implicit operator Label(int offset) => new(offset);
-		public static Label operator +(Label label, int offset) => new(label._offset + offset);
-		public static Label operator -(Label label, int offset) => new(label._offset - offset);
-		public static int operator -(Label lhs, Label rhs) => lhs._offset - rhs._offset;
-		public static bool operator ==(Label lhs, Label rhs) => lhs.Equals(rhs);
-		public static bool operator !=(Label lhs, Label rhs) => !lhs.Equals(rhs);
-		public static bool operator >(Label lhs, Label rhs) => lhs.CompareTo(rhs) > 0;
-		public static bool operator <(Label lhs, Label rhs) => lhs.CompareTo(rhs) < 0;
-		public static bool operator >=(Label lhs, Label rhs) => lhs.CompareTo(rhs) >= 0;
-		public static bool operator <=(Label lhs, Label rhs) => lhs.CompareTo(rhs) <= 0;
+	public static explicit operator int(Label label) => label._offset;
+	public static implicit operator Label(int offset) => new(offset);
+	public static Label operator +(Label label, int offset) => new(label._offset + offset);
+	public static Label operator -(Label label, int offset) => new(label._offset - offset);
+	public static int operator -(Label lhs, Label rhs) => lhs._offset - rhs._offset;
+	public static bool operator ==(Label lhs, Label rhs) => lhs.Equals(rhs);
+	public static bool operator !=(Label lhs, Label rhs) => !lhs.Equals(rhs);
+	public static bool operator >(Label lhs, Label rhs) => lhs.CompareTo(rhs) > 0;
+	public static bool operator <(Label lhs, Label rhs) => lhs.CompareTo(rhs) < 0;
+	public static bool operator >=(Label lhs, Label rhs) => lhs.CompareTo(rhs) >= 0;
+	public static bool operator <=(Label lhs, Label rhs) => lhs.CompareTo(rhs) <= 0;
 
-		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
-		readonly int _offset = offset;
-	}
+	[DebuggerBrowsable(DebuggerBrowsableState.Never)]
+	readonly int _offset = offset;
 }
diff --git a/src/MethodCheck.Core/Data/Values/MetadataToken.cs b/src/MethodCheck.Core/Data/Values/MetadataToken.cs
index 6b2ae78..aceeff6 100644
--- a/src/MethodCheck.Core/Data/Values/MetadataToken.cs
+++ b/src/MethodCheck.Core/Data/Values/MetadataToken.cs
@@ -3,21 +3,20 @@
 using System.Diagnostics;
 using System.Globalization;
 
-namespace MethodCheck.Core.Data
+namespace MethodCheck.Core.Data;
+
+public readonly struct MetadataToken(int token) : IEquatable<MetadataToken>
 {
-	public readonly struct MetadataToken(int token) : IEquatable<MetadataToken>
-	{
-		public override bool Equals(object? obj) => obj is MetadataToken token && Equals(token);
-		public bool Equals(MetadataToken other) => other._token == _token;
-		public override int GetHashCode() => _token;
-		public override string ToString() => _token.ToString("X8", CultureInfo.InvariantCulture);
+	public override bool Equals(object? obj) => obj is MetadataToken token && Equals(token);
+	public bool Equals(MetadataToken other) => other._token == _token;
+	public override int GetHashCode() => _token;
+	public override string ToString() => _token.ToString("X8", CultureInfo.InvariantCulture);
 
-		public static bool operator ==(MetadataToken token1, MetadataToken token2) => token1._token == token2._token;
-		public static bool operator !=(MetadataToken token1, MetadataToken token2) => token1._token != token2._token;
+	public static bool operator ==(MetadataToken token1, MetadataToken token2) => token1._token == token2._token;
+	public static bool operator !=(MetadataToken token1, MetadataToken token2) => token1._token != token2._token;
 
-		public static implicit operator MetadataToken(int token) => new(token);
+	public static implicit operator MetadataToken(int token) => new(token);
 
-		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
-		readonly int _token = token;
-	}
+	[DebuggerBrowsable(DebuggerBrowsableState.Never)]
+	readonly int _token = token;
 }
diff --git a/src/MethodCheck.Core/MethodFormatter.cs b/src/MethodCheck.Core/MethodFormatter.cs
index 9a2f5eb..bbaafd0 100644
--- a/src/MethodCheck.Core/MethodFormatter.cs
+++ b/src/MethodCheck.Core/MethodFormatter.cs
@@ -7,488 +7,487 @@
 using MethodCheck.Core.Data.Sections;
 using FlowControl = System.Reflection.Emit.FlowControl;
 
-namespace MethodCheck.Core
+namespace MethodCheck.Core;
+
+public static class MethodFormatter
 {
-	public static class MethodFormatter
+	public static string Format(MethodData data, bool inlineExceptionHandlers = false)
 	{
-		public static string Format(MethodData data, bool inlineExceptionHandlers = false)
-		{
-			ArgumentNullException.ThrowIfNull(data);
+		ArgumentNullException.ThrowIfNull(data);
 
-			var sections = inlineExceptionHandlers ? BuildSections(data) : null;
-			var builder = new StringBuilder();
-			var jumpTargets = CollectJumpTargets(data, sections == null);
+		var sections = inlineExceptionHandlers ? BuildSections(data) : null;
+		var builder = new StringBuilder();
+		var jumpTargets = CollectJumpTargets(data, sections == null);
 
-			WriteHeader(data, builder);
+		WriteHeader(data, builder);
 
-			var writer = new InstructionWriter(builder, jumpTargets, data.Instructions);
+		var writer = new InstructionWriter(builder, jumpTargets, data.Instructions);
+
+		if (sections != null)
+		{
+			writer.WriteInstructions(sections);
+		}
+		else
+		{
+			writer.WriteInstructions();
+			WriteExceptionHandlers(data, builder);
+		}
 
-			if (sections != null)
+		return builder.ToString();
+	}
+
+	static BaseSection? BuildSections(MethodData data)
+	{
+		var ilRange = InstructionsRange(data.Instructions);
+		BaseSection? sections = null;
+
+		foreach (var dataSection in data.DataSections)
+		{
+			if (dataSection.ExceptionHandlers.Length > 0)
 			{
-				writer.WriteInstructions(sections);
+				if (sections != null)
+				{
+					return null;
+				}
+
+				try
+				{
+					sections = SectionFactory.Create(ilRange, dataSection.ExceptionHandlers);
+				}
+				catch (CannotGenerateSectionException)
+				{
+					return null;
+				}
 			}
-			else
+		}
+
+		return sections;
+	}
+
+	static void WriteExceptionHandlers(MethodData data, StringBuilder builder)
+	{
+		var started = false;
+
+		foreach (var section in data.DataSections)
+		{
+			foreach (var handler in section.ExceptionHandlers)
 			{
-				writer.WriteInstructions();
-				WriteExceptionHandlers(data, builder);
-			}
+				if (!started)
+				{
+					started = true;
+					builder.AppendLine();
+				}
 
-			return builder.ToString();
+				WriteExceptionHandler(builder, handler);
+			}
 		}
+	}
+
+	static void WriteExceptionHandler(StringBuilder builder, ExceptionHandler handler)
+	{
+		builder
+			.Append(".try ")
+			.Append(handler.TryRange.Offset)
+			.Append(" to ")
+			.Append(handler.TryRange.Offset + handler.TryRange.Length);
 
-		static BaseSection? BuildSections(MethodData data)
+		switch (handler.Type)
 		{
-			var ilRange = InstructionsRange(data.Instructions);
-			BaseSection? sections = null;
+			case ExceptionHandlingClauseOptions.Clause:
+				builder
+					.Append(" catch ")
+					.Append((MetadataToken)handler.FilterOrType)
+					.Append(' ');
+				break;
+
+			case ExceptionHandlingClauseOptions.Fault:
+				builder.Append(" fault ");
+				break;
+
+			case ExceptionHandlingClauseOptions.Finally:
+				builder.Append(" finally ");
+				break;
+
+			case ExceptionHandlingClauseOptions.Filter:
+				builder
+					.Append(" filter ")
+					.Append(new Label(handler.FilterOrType))
+					.Append(' ');
+				break;
+		}
+
+		builder
+			.Append(handler.HandlerRange.Offset)
+			.Append(" to ")
+			.Append(handler.HandlerRange.Offset + handler.HandlerRange.Length)
+			.AppendLine();
+	}
+
+	static ImmutableHashSet<Label> CollectJumpTargets(MethodData data, bool includeExceptionHandlers)
+	{
+		var jumpTargets = ImmutableHashSet.CreateBuilder<Label>();
 
-			foreach (var dataSection in data.DataSections)
+		foreach (var instruction in data.Instructions)
+		{
+			switch (instruction.Argument)
 			{
-				if (dataSection.ExceptionHandlers.Length > 0)
-				{
-					if (sections != null)
-					{
-						return null;
-					}
+				case Label label:
+					jumpTargets.Add(label);
+					break;
 
-					try
-					{
-						sections = SectionFactory.Create(ilRange, dataSection.ExceptionHandlers);
-					}
-					catch (CannotGenerateSectionException)
+				case ImmutableArray<Label> labels:
+					for (var i = 0; i < labels.Length; i++)
 					{
-						return null;
+						jumpTargets.Add(labels[i]);
 					}
-				}
+					break;
 			}
-
-			return sections;
 		}
 
-		static void WriteExceptionHandlers(MethodData data, StringBuilder builder)
+		if (includeExceptionHandlers)
 		{
-			var started = false;
-
 			foreach (var section in data.DataSections)
 			{
 				foreach (var handler in section.ExceptionHandlers)
 				{
-					if (!started)
+					jumpTargets.Add(handler.TryRange.Offset);
+					jumpTargets.Add(handler.TryRange.Offset + handler.TryRange.Length);
+					jumpTargets.Add(handler.HandlerRange.Offset);
+					jumpTargets.Add(handler.HandlerRange.Offset + handler.HandlerRange.Length);
+
+					if (handler.Type == ExceptionHandlingClauseOptions.Filter)
 					{
-						started = true;
-						builder.AppendLine();
+						jumpTargets.Add(new Label(handler.FilterOrType));
 					}
-
-					WriteExceptionHandler(builder, handler);
 				}
 			}
 		}
 
-		static void WriteExceptionHandler(StringBuilder builder, ExceptionHandler handler)
+		return jumpTargets.ToImmutable();
+	}
+
+	static void WriteHeader(MethodData data, StringBuilder builder)
+	{
+		if (data.MaxStack != 0)
 		{
 			builder
-				.Append(".try ")
-				.Append(handler.TryRange.Offset)
-				.Append(" to ")
-				.Append(handler.TryRange.Offset + handler.TryRange.Length);
-
-			switch (handler.Type)
-			{
-				case ExceptionHandlingClauseOptions.Clause:
-					builder
-						.Append(" catch ")
-						.Append((MetadataToken)handler.FilterOrType)
-						.Append(' ');
-					break;
-
-				case ExceptionHandlingClauseOptions.Fault:
-					builder.Append(" fault ");
-					break;
+				.Append(".maxstack ")
+				.Append(data.MaxStack)
+				.AppendLine();
+		}
 
-				case ExceptionHandlingClauseOptions.Finally:
-					builder.Append(" finally ");
-					break;
+		if (data.LocalsToken != 0)
+		{
+			builder.Append(".locals ");
 
-				case ExceptionHandlingClauseOptions.Filter:
-					builder
-						.Append(" filter ")
-						.Append(new Label(handler.FilterOrType))
-						.Append(' ');
-					break;
+			if ((data.Flags & MethodDataFlags.InitFields) != 0)
+			{
+				builder.Append("init ");
 			}
 
 			builder
-				.Append(handler.HandlerRange.Offset)
-				.Append(" to ")
-				.Append(handler.HandlerRange.Offset + handler.HandlerRange.Length)
+				.Append(data.LocalsToken)
+				.AppendLine();
+		}
+
+		if (data.CodeSize != 0)
+		{
+			builder
+				.Append("// code size: ")
+				.Append(data.CodeSize)
 				.AppendLine();
 		}
+	}
 
-		static ImmutableHashSet<Label> CollectJumpTargets(MethodData data, bool includeExceptionHandlers)
+	static ILRange InstructionsRange(ImmutableArray<Instruction> instructions)
+	{
+		if (instructions.Length == 0)
 		{
-			var jumpTargets = ImmutableHashSet.CreateBuilder<Label>();
+			return default;
+		}
+
+		var start = instructions[0].Range.Offset;
+		var lastInstruction = instructions[instructions.Length - 1];
+		var end = lastInstruction.Range.Offset + lastInstruction.Range.Length;
+		return new ILRange(start, end - start);
+	}
 
-			foreach (var instruction in data.Instructions)
+	struct InstructionWriter(
+		StringBuilder builder,
+		ImmutableHashSet<Label> jumpTargets,
+		ImmutableArray<Instruction> instructions)
+	{
+		public void WriteInstructions()
+		{
+			foreach (var instruction in _instructions)
 			{
-				switch (instruction.Argument)
-				{
-					case Label label:
-						jumpTargets.Add(label);
-						break;
-
-					case ImmutableArray<Label> labels:
-						for (var i = 0; i < labels.Length; i++)
-						{
-							jumpTargets.Add(labels[i]);
-						}
-						break;
-				}
+				WriteInstruction(instruction);
 			}
+		}
 
-			if (includeExceptionHandlers)
+		public void WriteInstructions(BaseSection section)
+		{
+			switch (section)
 			{
-				foreach (var section in data.DataSections)
-				{
-					foreach (var handler in section.ExceptionHandlers)
+				case ILSection ilSection:
+					WriteInstructions(ilSection);
+					break;
+
+				case SequenceSection sequenceSection:
+					foreach (var subSection in sequenceSection.Sections)
 					{
-						jumpTargets.Add(handler.TryRange.Offset);
-						jumpTargets.Add(handler.TryRange.Offset + handler.TryRange.Length);
-						jumpTargets.Add(handler.HandlerRange.Offset);
-						jumpTargets.Add(handler.HandlerRange.Offset + handler.HandlerRange.Length);
-
-						if (handler.Type == ExceptionHandlingClauseOptions.Filter)
-						{
-							jumpTargets.Add(new Label(handler.FilterOrType));
-						}
+						WriteInstructions(subSection);
 					}
-				}
+					break;
+
+				case TryBlockSection trySection:
+					WriteInstructions(trySection);
+					break;
 			}
+		}
 
-			return jumpTargets.ToImmutable();
+		void WriteBlock(BaseSection section)
+		{
+			_pendingNewline = false;
+			StartBlock();
+			WriteInstructions(section);
+			EndBlock();
+			_pendingNewline = false;
 		}
 
-		static void WriteHeader(MethodData data, StringBuilder builder)
+		void WriteInstructions(ILSection section)
 		{
-			if (data.MaxStack != 0)
-			{
-				builder
-					.Append(".maxstack ")
-					.Append(data.MaxStack)
-					.AppendLine();
-			}
+			var index = IndexOf(section.Range.Offset);
+			var end = section.Range.Offset + section.Range.Length;
 
-			if (data.LocalsToken != 0)
+			while (index < _instructions.Length)
 			{
-				builder.Append(".locals ");
+				var instruction = _instructions[index++];
 
-				if ((data.Flags & MethodDataFlags.InitFields) != 0)
+				if (instruction.Range.Offset >= end)
 				{
-					builder.Append("init ");
+					break;
 				}
 
-				builder
-					.Append(data.LocalsToken)
-					.AppendLine();
+				WriteInstruction(instruction);
 			}
+		}
 
-			if (data.CodeSize != 0)
+		void WriteInstructions(TryBlockSection section)
+		{
+			WriteIndent();
+			_builder.Append(".try").AppendLine();
+
+			WriteBlock(section.TryBlock);
+
+			foreach (var handler in section.HandlerBlocks)
 			{
-				builder
-					.Append("// code size: ")
-					.Append(data.CodeSize)
-					.AppendLine();
+				WriteHandler(handler);
 			}
 		}
 
-		static ILRange InstructionsRange(ImmutableArray<Instruction> instructions)
+		void WriteInstruction(Instruction instruction)
 		{
-			if (instructions.Length == 0)
+			if (_jumpTargets.Contains(instruction.Range.Offset))
 			{
-				return default;
+				WriteLabelDef(instruction.Range.Offset);
 			}
 
-			var start = instructions[0].Range.Offset;
-			var lastInstruction = instructions[instructions.Length - 1];
-			var end = lastInstruction.Range.Offset + lastInstruction.Range.Length;
-			return new ILRange(start, end - start);
+			WriteInstructionCore(instruction);
 		}
 
-		struct InstructionWriter(
-			StringBuilder builder,
-			ImmutableHashSet<Label> jumpTargets,
-			ImmutableArray<Instruction> instructions)
+		void WriteHandler(HandlerBlock handler)
 		{
-			public void WriteInstructions()
-			{
-				foreach (var instruction in _instructions)
-				{
-					WriteInstruction(instruction);
-				}
-			}
+			WriteIndent();
 
-			public void WriteInstructions(BaseSection section)
-			{
-				switch (section)
-				{
-					case ILSection ilSection:
-						WriteInstructions(ilSection);
-						break;
-
-					case SequenceSection sequenceSection:
-						foreach (var subSection in sequenceSection.Sections)
-						{
-							WriteInstructions(subSection);
-						}
-						break;
-
-					case TryBlockSection trySection:
-						WriteInstructions(trySection);
-						break;
-				}
-			}
-
-			void WriteBlock(BaseSection section)
+			switch (handler.Type)
 			{
-				_pendingNewline = false;
-				StartBlock();
-				WriteInstructions(section);
-				EndBlock();
-				_pendingNewline = false;
-			}
+				case ExceptionHandlingClauseOptions.Fault:
+					_builder
+						.Append(".fault")
+						.AppendLine();
+					break;
 
-			void WriteInstructions(ILSection section)
-			{
-				var index = IndexOf(section.Range.Offset);
-				var end = section.Range.Offset + section.Range.Length;
+				case ExceptionHandlingClauseOptions.Finally:
+					_builder
+						.Append(".finally")
+						.AppendLine();
+					break;
 
-				while (index < _instructions.Length)
-				{
-					var instruction = _instructions[index++];
+				case ExceptionHandlingClauseOptions.Clause:
+				case ExceptionHandlingClauseOptions.Filter:
+					_builder.Append(".catch");
 
-					if (instruction.Range.Offset >= end)
+					if (handler.FilterSection != null)
 					{
-						break;
+						_builder.AppendLine();
+						WriteBlock(handler.FilterSection);
 					}
+					else if (handler.ExceptionType != default)
+					{
+						_builder
+							.Append(' ')
+							.Append(handler.ExceptionType)
+							.AppendLine();
+					}
+					break;
 
-					WriteInstruction(instruction);
-				}
-			}
-
-			void WriteInstructions(TryBlockSection section)
-			{
-				WriteIndent();
-				_builder.Append(".try").AppendLine();
-
-				WriteBlock(section.TryBlock);
-
-				foreach (var handler in section.HandlerBlocks)
-				{
-					WriteHandler(handler);
-				}
+				default:
+					throw new ArgumentException("Unknown handler type: " + handler.Type, nameof(handler));
 			}
 
-			void WriteInstruction(Instruction instruction)
-			{
-				if (_jumpTargets.Contains(instruction.Range.Offset))
-				{
-					WriteLabelDef(instruction.Range.Offset);
-				}
+			WriteBlock(handler.HandlerSection);
+		}
 
-				WriteInstructionCore(instruction);
-			}
+		void WriteInstructionCore(Instruction instruction)
+		{
+			BeginLine();
+			WriteIndent();
 
-			void WriteHandler(HandlerBlock handler)
+			switch (instruction.Kind)
 			{
-				WriteIndent();
+				case InstructionKind.Invalid:
+					_builder.Append("??");
+					break;
 
-				switch (handler.Type)
-				{
-					case ExceptionHandlingClauseOptions.Fault:
-						_builder
-							.Append(".fault")
-							.AppendLine();
-						break;
+				case InstructionKind.OpCode:
+					var name = instruction.OpCode.Name!;
+					_builder.Append(name);
 
-					case ExceptionHandlingClauseOptions.Finally:
-						_builder
-							.Append(".finally")
-							.AppendLine();
-						break;
-
-					case ExceptionHandlingClauseOptions.Clause:
-					case ExceptionHandlingClauseOptions.Filter:
-						_builder.Append(".catch");
-
-						if (handler.FilterSection != null)
-						{
-							_builder.AppendLine();
-							WriteBlock(handler.FilterSection);
-						}
-						else if (handler.ExceptionType != default)
-						{
-							_builder
-								.Append(' ')
-								.Append(handler.ExceptionType)
-								.AppendLine();
-						}
-						break;
-
-					default:
-						throw new ArgumentException("Unknown handler type: " + handler.Type, nameof(handler));
-				}
+					if (instruction.Argument != null)
+					{
+						_builder.Append(' ', Instruction.MaxMnemonicLength + 2 - name.Length);
+						WriteArgument(instruction);
+					}
 
-				WriteBlock(handler.HandlerSection);
+					switch (instruction.OpCode.FlowControl)
+					{
+						case FlowControl.Branch:
+						case FlowControl.Return:
+						case FlowControl.Throw:
+							_pendingNewline = true;
+							break;
+					}
+					break;
 			}
 
-			void WriteInstructionCore(Instruction instruction)
-			{
-				BeginLine();
-				WriteIndent();
-
-				switch (instruction.Kind)
-				{
-					case InstructionKind.Invalid:
-						_builder.Append("??");
-						break;
-
-					case InstructionKind.OpCode:
-						var name = instruction.OpCode.Name!;
-						_builder.Append(name);
-
-						if (instruction.Argument != null)
-						{
-							_builder.Append(' ', Instruction.MaxMnemonicLength + 2 - name.Length);
-							WriteArgument(instruction);
-						}
-
-						switch (instruction.OpCode.FlowControl)
-						{
-							case FlowControl.Branch:
-							case FlowControl.Return:
-							case FlowControl.Throw:
-								_pendingNewline = true;
-								break;
-						}
-						break;
-				}
+			_builder.AppendLine();
+		}
 
-				_builder.AppendLine();
-			}
+		void WriteLabelDef(Label label)
+		{
+			BeginLine();
+			_builder
+				.Append(label)
+				.AppendLine();
+		}
 
-			void WriteLabelDef(Label label)
+		readonly void WriteArgument(Instruction instruction)
+		{
+			if (instruction.Argument == IncompleteArgument.Value)
 			{
-				BeginLine();
-				_builder
-					.Append(label)
-					.AppendLine();
+				_builder.Append("??");
+				return;
 			}
 
-			readonly void WriteArgument(Instruction instruction)
+			switch (instruction.Argument)
 			{
-				if (instruction.Argument == IncompleteArgument.Value)
-				{
-					_builder.Append("??");
-					return;
-				}
-
-				switch (instruction.Argument)
-				{
-					case Label label:
-						var diff = label - (instruction.Range.Offset + instruction.Range.Length);
-						_builder
-							.Append(label)
-							.Append(" // ");
+				case Label label:
+					var diff = label - (instruction.Range.Offset + instruction.Range.Length);
+					_builder
+						.Append(label)
+						.Append(" // ");
 
-						if (diff >= 0)
-						{
-							_builder.Append('+');
-						}
+					if (diff >= 0)
+					{
+						_builder.Append('+');
+					}
 
-						_builder.Append(diff);
-						break;
+					_builder.Append(diff);
+					break;
 
-					case ImmutableArray<Label> labels:
-						_builder.Append('{');
+				case ImmutableArray<Label> labels:
+					_builder.Append('{');
 
-						foreach (var label in labels)
-						{
-							_builder
-								.Append(' ')
-								.Append(label);
-						}
+					foreach (var label in labels)
+					{
+						_builder
+							.Append(' ')
+							.Append(label);
+					}
 
-						_builder.Append(" }");
-						break;
+					_builder.Append(" }");
+					break;
 
-					default:
-						_builder.Append(instruction.Argument);
-						break;
-				}
+				default:
+					_builder.Append(instruction.Argument);
+					break;
 			}
+		}
 
-			void StartBlock()
-			{
-				WriteIndent();
-				_builder
-					.Append('{')
-					.AppendLine();
-				_indentDepth++;
-			}
+		void StartBlock()
+		{
+			WriteIndent();
+			_builder
+				.Append('{')
+				.AppendLine();
+			_indentDepth++;
+		}
 
-			void EndBlock()
-			{
-				_indentDepth--;
-				WriteIndent();
-				_builder
-					.Append('}')
-					.AppendLine();
-			}
+		void EndBlock()
+		{
+			_indentDepth--;
+			WriteIndent();
+			_builder
+				.Append('}')
+				.AppendLine();
+		}
 
-			void BeginLine()
+		void BeginLine()
+		{
+			if (_pendingNewline)
 			{
-				if (_pendingNewline)
-				{
-					_pendingNewline = false;
-					_builder.AppendLine();
-				}
+				_pendingNewline = false;
+				_builder.AppendLine();
 			}
+		}
 
-			readonly void WriteIndent()
-			{
-				_builder.Append(' ', _indentDepth * 2);
-			}
+		readonly void WriteIndent()
+		{
+			_builder.Append(' ', _indentDepth * 2);
+		}
+
+		readonly int IndexOf(Label label)
+		{
+			var min = 0;
+			var max = _instructions.Length - 1;
 
-			readonly int IndexOf(Label label)
+			while (min <= max)
 			{
-				var min = 0;
-				var max = _instructions.Length - 1;
+				var mid = (min + max) / 2;
+				var offset = _instructions[mid].Range.Offset;
 
-				while (min <= max)
+				if (label < offset)
 				{
-					var mid = (min + max) / 2;
-					var offset = _instructions[mid].Range.Offset;
-
-					if (label < offset)
-					{
-						max = mid - 1;
-					}
-					else if (label > offset)
-					{
-						min = mid + 1;
-					}
-					else
-					{
-						return mid;
-					}
+					max = mid - 1;
+				}
+				else if (label > offset)
+				{
+					min = mid + 1;
+				}
+				else
+				{
+					return mid;
 				}
-
-				throw new ArgumentException("Label does not correspond to an instruction.", nameof(label));
 			}
 
-			bool _pendingNewline = false;
-			int _indentDepth = 1;
-			readonly StringBuilder _builder = builder;
-			readonly ImmutableHashSet<Label> _jumpTargets = jumpTargets;
-			readonly ImmutableArray<Instruction> _instructions = instructions;
+			throw new ArgumentException("Label does not correspond to an instruction.", nameof(label));
 		}
+
+		bool _pendingNewline = false;
+		int _indentDepth = 1;
+		readonly StringBuilder _builder = builder;
+		readonly ImmutableHashSet<Label> _jumpTargets = jumpTargets;
+		readonly ImmutableArray<Instruction> _instructions = instructions;
 	}
 }
diff --git a/src/MethodCheck.Core/Parsing/ILReader.cs b/src/MethodCheck.Core/Parsing/ILReader.cs
index b6247b1..d324185 100644
--- a/src/MethodCheck.Core/Parsing/ILReader.cs
+++ b/src/MethodCheck.Core/Parsing/ILReader.cs
@@ -6,103 +6,102 @@
 using MethodCheck.Core.Data;
 using OpCode = System.Reflection.Emit.OpCode;
 
-namespace MethodCheck.Core.Parsing
+namespace MethodCheck.Core.Parsing;
+
+public ref partial struct ILReader(ReadOnlySpan<byte> buffer)
 {
-	public ref partial struct ILReader(ReadOnlySpan<byte> buffer)
-	{
-		public Instruction Current { get; private set; } = null!;
+	public Instruction Current { get; private set; } = null!;
 
-		public bool MoveNext()
+	public bool MoveNext()
+	{
+		if (_offset >= _buffer.Length)
 		{
-			if (_offset >= _buffer.Length)
-			{
-				Current = null!;
-				return false;
-			}
-			else
-			{
-				var tmp = Read();
-				_offset += tmp.Range.Length;
-				Current = tmp;
-				return true;
-			}
+			Current = null!;
+			return false;
 		}
+		else
+		{
+			var tmp = Read();
+			_offset += tmp.Range.Length;
+			Current = tmp;
+			return true;
+		}
+	}
+
+	readonly Instruction ReadInlineNoneInstruction(OpCode opcode) => CreateInstruction(opcode.Size, opcode, null);
+	readonly Instruction ReadShortInlineVarInstruction(OpCode opcode) => CreateInstruction<byte>(opcode);
+	readonly Instruction ReadShortInlineIInstruction(OpCode opcode) => CreateInstruction(opcode, (sbyte x, int end) => (int)x);
+	readonly Instruction ReadInlineIInstruction(OpCode opcode) => CreateInstruction<int>(opcode);
+	readonly Instruction ReadInlineI8Instruction(OpCode opcode) => CreateInstruction<long>(opcode);
+	readonly Instruction ReadShortInlineRInstruction(OpCode opcode) => CreateInstruction<float>(opcode);
+	readonly Instruction ReadInlineRInstruction(OpCode opcode) => CreateInstruction<double>(opcode);
+	readonly Instruction ReadInlineTokInstruction(OpCode opcode) => CreateInstruction(opcode, (int x, int end) => new MetadataToken(x));
+	readonly Instruction ReadInlineVarInstruction(OpCode opcode) => CreateInstruction<ushort>(opcode);
+	readonly Instruction InvalidInstruction(int length) => new(new ILRange(_offset, length));
+	readonly Instruction ReadShortInlineBrTargetInstruction(OpCode opcode) => CreateInstruction(opcode, (sbyte x, int end) => new Label(end + x));
+	readonly Instruction ReadInlineBrTargetInstruction(OpCode opcode) => CreateInstruction(opcode, (int x, int end) => new Label(end + x));
+
+	readonly Instruction ReadInlineSwitchInstruction(OpCode opcode)
+	{
+		var argStart = _offset + opcode.Size;
 
-		readonly Instruction ReadInlineNoneInstruction(OpCode opcode) => CreateInstruction(opcode.Size, opcode, null);
-		readonly Instruction ReadShortInlineVarInstruction(OpCode opcode) => CreateInstruction<byte>(opcode);
-		readonly Instruction ReadShortInlineIInstruction(OpCode opcode) => CreateInstruction(opcode, (sbyte x, int end) => (int)x);
-		readonly Instruction ReadInlineIInstruction(OpCode opcode) => CreateInstruction<int>(opcode);
-		readonly Instruction ReadInlineI8Instruction(OpCode opcode) => CreateInstruction<long>(opcode);
-		readonly Instruction ReadShortInlineRInstruction(OpCode opcode) => CreateInstruction<float>(opcode);
-		readonly Instruction ReadInlineRInstruction(OpCode opcode) => CreateInstruction<double>(opcode);
-		readonly Instruction ReadInlineTokInstruction(OpCode opcode) => CreateInstruction(opcode, (int x, int end) => new MetadataToken(x));
-		readonly Instruction ReadInlineVarInstruction(OpCode opcode) => CreateInstruction<ushort>(opcode);
-		readonly Instruction InvalidInstruction(int length) => new(new ILRange(_offset, length));
-		readonly Instruction ReadShortInlineBrTargetInstruction(OpCode opcode) => CreateInstruction(opcode, (sbyte x, int end) => new Label(end + x));
-		readonly Instruction ReadInlineBrTargetInstruction(OpCode opcode) => CreateInstruction(opcode, (int x, int end) => new Label(end + x));
-
-		readonly Instruction ReadInlineSwitchInstruction(OpCode opcode)
+		if (argStart + 4 < _buffer.Length)
 		{
-			var argStart = _offset + opcode.Size;
+			var values = MemoryMarshal.Cast<byte, int>(_buffer.Slice(argStart));
+			var labelCount = values[0];
 
-			if (argStart + 4 < _buffer.Length)
+			if (labelCount + 1 < values.Length)
 			{
-				var values = MemoryMarshal.Cast<byte, int>(_buffer.Slice(argStart));
-				var labelCount = values[0];
-
-				if (labelCount + 1 < values.Length)
-				{
-					values = values.Slice(1, labelCount);
-					var relativeOffset = argStart + 4 + (labelCount * 4);
-					var argument = CreateLabelList(relativeOffset, values);
-					return CreateInstruction(relativeOffset - _offset, opcode, argument);
-				}
+				values = values.Slice(1, labelCount);
+				var relativeOffset = argStart + 4 + (labelCount * 4);
+				var argument = CreateLabelList(relativeOffset, values);
+				return CreateInstruction(relativeOffset - _offset, opcode, argument);
 			}
-
-			return CreateInstruction(_buffer.Length - _offset, opcode, IncompleteArgument.Value);
 		}
 
-		readonly Instruction CreateInstruction<T>(OpCode opCode)
-			where T : unmanaged
-			=> CreateInstruction(opCode, (T x, int end) => x);
+		return CreateInstruction(_buffer.Length - _offset, opcode, IncompleteArgument.Value);
+	}
 
-		readonly Instruction CreateInstruction<TIn, TOut>(OpCode opCode, Func<TIn, int, TOut> converter)
-			where TIn : unmanaged
-			where TOut : notnull
-		{
-			object value;
-			var length = opCode.Size + Unsafe.SizeOf<TIn>();
-			var end = _offset + length;
+	readonly Instruction CreateInstruction<T>(OpCode opCode)
+		where T : unmanaged
+		=> CreateInstruction(opCode, (T x, int end) => x);
 
-			if (end <= _buffer.Length)
-			{
-				var rawValue = MemoryMarshal.Read<TIn>(_buffer.Slice(_offset + opCode.Size));
-				value = converter(rawValue, end);
-			}
-			else
-			{
-				value = IncompleteArgument.Value;
-			}
+	readonly Instruction CreateInstruction<TIn, TOut>(OpCode opCode, Func<TIn, int, TOut> converter)
+		where TIn : unmanaged
+		where TOut : notnull
+	{
+		object value;
+		var length = opCode.Size + Unsafe.SizeOf<TIn>();
+		var end = _offset + length;
 
-			return CreateInstruction(length, opCode, value);
+		if (end <= _buffer.Length)
+		{
+			var rawValue = MemoryMarshal.Read<TIn>(_buffer.Slice(_offset + opCode.Size));
+			value = converter(rawValue, end);
+		}
+		else
+		{
+			value = IncompleteArgument.Value;
 		}
 
-		readonly Instruction CreateInstruction(int length, OpCode opcode, object? value) => new(new ILRange(_offset, length), opcode, value);
+		return CreateInstruction(length, opCode, value);
+	}
 
-		static ImmutableArray<Label> CreateLabelList(int relativeOffset, ReadOnlySpan<int> offsets)
-		{
-			var builder = ImmutableArray.CreateBuilder<Label>(offsets.Length);
-			builder.Count = offsets.Length;
+	readonly Instruction CreateInstruction(int length, OpCode opcode, object? value) => new(new ILRange(_offset, length), opcode, value);
 
-			for (var i = 0; i < offsets.Length; i++)
-			{
-				builder[i] = new Label(relativeOffset + offsets[i]);
-			}
+	static ImmutableArray<Label> CreateLabelList(int relativeOffset, ReadOnlySpan<int> offsets)
+	{
+		var builder = ImmutableArray.CreateBuilder<Label>(offsets.Length);
+		builder.Count = offsets.Length;
 
-			return builder.MoveToImmutable();
+		for (var i = 0; i < offsets.Length; i++)
+		{
+			builder[i] = new Label(relativeOffset + offsets[i]);
 		}
 
-		readonly ReadOnlySpan<byte> _buffer = buffer;
-		int _offset = 0;
+		return builder.MoveToImmutable();
 	}
+
+	readonly ReadOnlySpan<byte> _buffer = buffer;
+	int _offset = 0;
 }
diff --git a/src/MethodCheck.Core/Parsing/MethodParser.cs b/src/MethodCheck.Core/Parsing/MethodParser.cs
index 30a1a5d..aa8d71c 100644
--- a/src/MethodCheck.Core/Parsing/MethodParser.cs
+++ b/src/MethodCheck.Core/Parsing/MethodParser.cs
@@ -5,246 +5,245 @@
 using System.Runtime.InteropServices;
 using MethodCheck.Core.Data;
 
-namespace MethodCheck.Core.Parsing
+namespace MethodCheck.Core.Parsing;
+
+public static class MethodParser
 {
-	public static class MethodParser
+	public static MethodData? ParseBody(ReadOnlySpan<byte> buffer)
 	{
-		public static MethodData? ParseBody(ReadOnlySpan<byte> buffer)
+		if (buffer.Length == 0)
 		{
-			if (buffer.Length == 0)
-			{
-				return null;
-			}
+			return null;
+		}
 
-			var type = buffer[0] & 0x03;
+		var type = buffer[0] & 0x03;
 
-			try
+		try
+		{
+			if (type == CorILMethod_TinyFormat)
 			{
-				if (type == CorILMethod_TinyFormat)
-				{
-					return ParseTiny(buffer);
-				}
-				else if (type == CorILMethod_FatFormat)
-				{
-					return ParseFat(buffer);
-				}
+				return ParseTiny(buffer);
 			}
-			catch (ArgumentException)
+			else if (type == CorILMethod_FatFormat)
 			{
+				return ParseFat(buffer);
 			}
+		}
+		catch (ArgumentException)
+		{
+		}
 
-			return null;
+		return null;
+	}
+
+	public static MethodData ParseIL(ReadOnlySpan<byte> buffer)
+	{
+		return new MethodData(
+			default,
+			0,
+			0,
+			MethodDataFlags.None,
+			ReadIL(buffer),
+			ImmutableArray<MethodDataSection>.Empty);
+	}
+
+	static MethodData ParseTiny(ReadOnlySpan<byte> buffer)
+	{
+		var codeSize = buffer[0] >> 2;
+
+		return new MethodData(
+			default,
+			8,
+			codeSize,
+			MethodDataFlags.None,
+			ReadIL(buffer.Slice(1, codeSize)),
+			ImmutableArray<MethodDataSection>.Empty);
+	}
+
+	static MethodData? ParseFat(ReadOnlySpan<byte> buffer)
+	{
+		if (buffer.Length < 12) return null;
+		var header = MemoryMarshal.Cast<byte, FatMethodHeader>(buffer)[0];
+		var headerLength = buffer[1] >> 2 & 0x3C;
+
+		ImmutableArray<MethodDataSection> dataSections;
+
+		if ((buffer[0] & CorILMethod_MoreSects) != 0)
+		{
+			var sectionStart = (headerLength + header.CodeSize + 3) & ~3;
+			dataSections = CreateSections(buffer.Slice(sectionStart));
+		}
+		else
+		{
+			dataSections = ImmutableArray<MethodDataSection>.Empty;
 		}
 
-		public static MethodData ParseIL(ReadOnlySpan<byte> buffer)
+		var flags = MethodDataFlags.None;
+
+		if ((buffer[0] & CorILMethod_InitLocals) != 0)
 		{
-			return new MethodData(
-				default,
-				0,
-				0,
-				MethodDataFlags.None,
-				ReadIL(buffer),
-				ImmutableArray<MethodDataSection>.Empty);
+			flags = MethodDataFlags.InitFields;
 		}
 
-		static MethodData ParseTiny(ReadOnlySpan<byte> buffer)
+		return new MethodData(
+			header.LocalVarSigTok,
+			header.MaxStack,
+			header.CodeSize,
+			flags,
+			ReadIL(buffer.Slice(headerLength, header.CodeSize)),
+			dataSections);
+	}
+
+	static ImmutableArray<Instruction> ReadIL(ReadOnlySpan<byte> buffer)
+	{
+		if (buffer.IsEmpty)
 		{
-			var codeSize = buffer[0] >> 2;
-
-			return new MethodData(
-				default,
-				8,
-				codeSize,
-				MethodDataFlags.None,
-				ReadIL(buffer.Slice(1, codeSize)),
-				ImmutableArray<MethodDataSection>.Empty);
+			return ImmutableArray<Instruction>.Empty;
 		}
 
-		static MethodData? ParseFat(ReadOnlySpan<byte> buffer)
+		var result = ImmutableArray.CreateBuilder<Instruction>();
+		var reader = new ILReader(buffer);
+
+		while (reader.MoveNext())
 		{
-			if (buffer.Length < 12) return null;
-			var header = MemoryMarshal.Cast<byte, FatMethodHeader>(buffer)[0];
-			var headerLength = buffer[1] >> 2 & 0x3C;
+			result.Add(reader.Current);
+		}
 
-			ImmutableArray<MethodDataSection> dataSections;
+		return result.ToImmutable();
+	}
 
-			if ((buffer[0] & CorILMethod_MoreSects) != 0)
-			{
-				var sectionStart = (headerLength + header.CodeSize + 3) & ~3;
-				dataSections = CreateSections(buffer.Slice(sectionStart));
-			}
-			else
-			{
-				dataSections = ImmutableArray<MethodDataSection>.Empty;
-			}
+	static ImmutableArray<MethodDataSection> CreateSections(ReadOnlySpan<byte> buffer)
+	{
+		var start = 0;
+		var builder = ImmutableArray.CreateBuilder<MethodDataSection>();
 
-			var flags = MethodDataFlags.None;
+		while (start < buffer.Length)
+		{
+			var flags = buffer[start];
+			int dataSize;
 
-			if ((buffer[0] & CorILMethod_InitLocals) != 0)
+			if ((flags & CorILMethod_Sect_FatFormat) == 0)
 			{
-				flags = MethodDataFlags.InitFields;
+				dataSize = buffer[start + 1];
 			}
-
-			return new MethodData(
-				header.LocalVarSigTok,
-				header.MaxStack,
-				header.CodeSize,
-				flags,
-				ReadIL(buffer.Slice(headerLength, header.CodeSize)),
-				dataSections);
-		}
-
-		static ImmutableArray<Instruction> ReadIL(ReadOnlySpan<byte> buffer)
-		{
-			if (buffer.IsEmpty)
+			else
 			{
-				return ImmutableArray<Instruction>.Empty;
+				dataSize = MemoryMarshal.Read<int>(buffer) >> 8;
 			}
 
-			var result = ImmutableArray.CreateBuilder<Instruction>();
-			var reader = new ILReader(buffer);
+			builder.Add(CreateSection(buffer.Slice(start, dataSize)));
 
-			while (reader.MoveNext())
+			if ((flags & CorILMethod_Sect_MoreSects) == 0)
 			{
-				result.Add(reader.Current);
+				break;
 			}
 
-			return result.ToImmutable();
+			start += dataSize;
 		}
 
-		static ImmutableArray<MethodDataSection> CreateSections(ReadOnlySpan<byte> buffer)
-		{
-			var start = 0;
-			var builder = ImmutableArray.CreateBuilder<MethodDataSection>();
-
-			while (start < buffer.Length)
-			{
-				var flags = buffer[start];
-				int dataSize;
+		return builder.ToImmutable();
+	}
 
-				if ((flags & CorILMethod_Sect_FatFormat) == 0)
-				{
-					dataSize = buffer[start + 1];
-				}
-				else
+	static MethodDataSection CreateSection(ReadOnlySpan<byte> sectionBuffer)
+	{
+		switch (sectionBuffer[0] & 0x7F)
+		{
+			case CorILMethod_Sect_EHTable:
 				{
-					dataSize = MemoryMarshal.Read<int>(buffer) >> 8;
+					var clauses = MemoryMarshal.Cast<byte, SmallExceptionClause>(sectionBuffer.Slice(4));
+					return new MethodDataSection(CreateHandlers(clauses));
 				}
 
-				builder.Add(CreateSection(buffer.Slice(start, dataSize)));
-
-				if ((flags & CorILMethod_Sect_MoreSects) == 0)
+			case CorILMethod_Sect_EHTable | CorILMethod_Sect_FatFormat:
 				{
-					break;
+					var clauses = MemoryMarshal.Cast<byte, FatExceptionClause>(sectionBuffer.Slice(4));
+					return new MethodDataSection(CreateHandlers(clauses));
 				}
 
-				start += dataSize;
-			}
-
-			return builder.ToImmutable();
+			default:
+				return new MethodDataSection(ImmutableArray<ExceptionHandler>.Empty);
 		}
+	}
 
-		static MethodDataSection CreateSection(ReadOnlySpan<byte> sectionBuffer)
-		{
-			switch (sectionBuffer[0] & 0x7F)
-			{
-				case CorILMethod_Sect_EHTable:
-					{
-						var clauses = MemoryMarshal.Cast<byte, SmallExceptionClause>(sectionBuffer.Slice(4));
-						return new MethodDataSection(CreateHandlers(clauses));
-					}
-
-				case CorILMethod_Sect_EHTable | CorILMethod_Sect_FatFormat:
-					{
-						var clauses = MemoryMarshal.Cast<byte, FatExceptionClause>(sectionBuffer.Slice(4));
-						return new MethodDataSection(CreateHandlers(clauses));
-					}
-
-				default:
-					return new MethodDataSection(ImmutableArray<ExceptionHandler>.Empty);
-			}
-		}
+	static ImmutableArray<ExceptionHandler> CreateHandlers(ReadOnlySpan<FatExceptionClause> clauses)
+	{
+		var handlers = ImmutableArray.CreateBuilder<ExceptionHandler>(clauses.Length);
 
-		static ImmutableArray<ExceptionHandler> CreateHandlers(ReadOnlySpan<FatExceptionClause> clauses)
+		for (var i = 0; i < clauses.Length; i++)
 		{
-			var handlers = ImmutableArray.CreateBuilder<ExceptionHandler>(clauses.Length);
-
-			for (var i = 0; i < clauses.Length; i++)
-			{
-				handlers.Add(CreateHandler(clauses[i]));
-			}
-
-			return handlers.MoveToImmutable();
+			handlers.Add(CreateHandler(clauses[i]));
 		}
 
-		static ImmutableArray<ExceptionHandler> CreateHandlers(ReadOnlySpan<SmallExceptionClause> clauses)
-		{
-			var handlers = ImmutableArray.CreateBuilder<ExceptionHandler>(clauses.Length);
-
-			for (var i = 0; i < clauses.Length; i++)
-			{
-				handlers.Add(CreateHandler(clauses[i]));
-			}
+		return handlers.MoveToImmutable();
+	}
 
-			return handlers.MoveToImmutable();
-		}
+	static ImmutableArray<ExceptionHandler> CreateHandlers(ReadOnlySpan<SmallExceptionClause> clauses)
+	{
+		var handlers = ImmutableArray.CreateBuilder<ExceptionHandler>(clauses.Length);
 
-		static ExceptionHandler CreateHandler(in FatExceptionClause clause)
+		for (var i = 0; i < clauses.Length; i++)
 		{
-			return new ExceptionHandler(
-				(ExceptionHandlingClauseOptions)clause.Flags,
-				new ILRange(clause.TryOffset, clause.TryLength),
-				new ILRange(clause.HandlerOffset, clause.HandlerLength),
-				clause.FilterOrType);
+			handlers.Add(CreateHandler(clauses[i]));
 		}
 
-		static ExceptionHandler CreateHandler(in SmallExceptionClause clause)
-		{
-			return new ExceptionHandler(
-				(ExceptionHandlingClauseOptions)clause.Flags,
-				new ILRange(clause.TryOffset, clause.TryLength),
-				new ILRange(clause.HandlerOffset, clause.HandlerLength),
-				clause.FilterOrType);
-		}
+		return handlers.MoveToImmutable();
+	}
 
-		const int CorILMethod_FatFormat = 0x03;
-		const int CorILMethod_TinyFormat = 0x02;
-		const int CorILMethod_MoreSects = 0x08;
-		const int CorILMethod_InitLocals = 0x10;
+	static ExceptionHandler CreateHandler(in FatExceptionClause clause)
+	{
+		return new ExceptionHandler(
+			(ExceptionHandlingClauseOptions)clause.Flags,
+			new ILRange(clause.TryOffset, clause.TryLength),
+			new ILRange(clause.HandlerOffset, clause.HandlerLength),
+			clause.FilterOrType);
+	}
 
-		const int CorILMethod_Sect_EHTable = 0x01;
-		const int CorILMethod_Sect_FatFormat = 0x40;
-		const int CorILMethod_Sect_MoreSects = 0x80;
+	static ExceptionHandler CreateHandler(in SmallExceptionClause clause)
+	{
+		return new ExceptionHandler(
+			(ExceptionHandlingClauseOptions)clause.Flags,
+			new ILRange(clause.TryOffset, clause.TryLength),
+			new ILRange(clause.HandlerOffset, clause.HandlerLength),
+			clause.FilterOrType);
+	}
 
-		[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 12)]
-		struct FatMethodHeader
-		{
-			public ushort FlagsAndSize;
-			public ushort MaxStack;
-			public int CodeSize;
-			public int LocalVarSigTok;
-		}
+	const int CorILMethod_FatFormat = 0x03;
+	const int CorILMethod_TinyFormat = 0x02;
+	const int CorILMethod_MoreSects = 0x08;
+	const int CorILMethod_InitLocals = 0x10;
 
-		[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 24)]
-		struct FatExceptionClause
-		{
-			public int Flags;
-			public int TryOffset;
-			public int TryLength;
-			public int HandlerOffset;
-			public int HandlerLength;
-			public int FilterOrType;
-		}
+	const int CorILMethod_Sect_EHTable = 0x01;
+	const int CorILMethod_Sect_FatFormat = 0x40;
+	const int CorILMethod_Sect_MoreSects = 0x80;
 
-		[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 12)]
-		struct SmallExceptionClause
-		{
-			public ushort Flags;
-			public ushort TryOffset;
-			public byte TryLength;
-			public ushort HandlerOffset;
-			public byte HandlerLength;
-			public int FilterOrType;
-		}
+	[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 12)]
+	struct FatMethodHeader
+	{
+		public ushort FlagsAndSize;
+		public ushort MaxStack;
+		public int CodeSize;
+		public int LocalVarSigTok;
+	}
+
+	[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 24)]
+	struct FatExceptionClause
+	{
+		public int Flags;
+		public int TryOffset;
+		public int TryLength;
+		public int HandlerOffset;
+		public int HandlerLength;
+		public int FilterOrType;
+	}
+
+	[StructLayout(LayoutKind.Sequential, Pack = 1, Size = 12)]
+	struct SmallExceptionClause
+	{
+		public ushort Flags;
+		public ushort TryOffset;
+		public byte TryLength;
+		public ushort HandlerOffset;
+		public byte HandlerLength;
+		public int FilterOrType;
 	}
 }
diff --git a/src/MethodCheck.Test/BinaryProcessorTest.cs b/src/MethodCheck.Test/BinaryProcessorTest.cs
index fb521b3..54d5ec6 100644
--- a/src/MethodCheck.Test/BinaryProcessorTest.cs
+++ b/src/MethodCheck.Test/BinaryProcessorTest.cs
@@ -3,113 +3,112 @@
 using MethodCheck.Core;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+class BinaryProcessorTest
 {
-	[TestFixture]
-	class BinaryProcessorTest
+	[TestCase("42 = 67")]
+	[TestCase("01 G0")]
+	[TestCase("0\u0011", TestName = "{m}(controlChar)")]
+	public void ParseInvalid(string text)
+	{
+		Assert.That(BinaryProcessor.Parse(text), Is.Null);
+	}
+
+	[Test]
+	public void ParseEmpty()
+	{
+		var blob = BinaryProcessor.Parse([]);
+		Assert.That(blob, Is.Empty);
+	}
+
+	[Test]
+	public void Parse()
+	{
+		var blob = BinaryProcessor.Parse("42 51 0A\r\n\r\n54".AsSpan());
+		Assert.That(blob, Is.EqualTo([0x42, 0x51, 0x0A, 0x54]));
+	}
+
+	[Test]
+	public void ParseLowercase()
+	{
+		var blob = BinaryProcessor.Parse("ab cd ef".AsSpan());
+		Assert.That(blob, Is.EqualTo([0xAB, 0xCD, 0xEF]));
+	}
+
+	[Test]
+	public void ParseUppercase()
+	{
+		var blob = BinaryProcessor.Parse("AB CD EF".AsSpan());
+		Assert.That(blob, Is.EqualTo([0xAB, 0xCD, 0xEF]));
+	}
+
+	[Test]
+	public void ParseHalfByte()
+	{
+		var blob = BinaryProcessor.Parse("4".AsSpan());
+		Assert.That(blob, Is.EqualTo([0x40]));
+	}
+
+	[Test]
+	public void ParseComments()
+	{
+		var blob = BinaryProcessor.Parse("42 51 0A // 05\r\n\r\n54".AsSpan());
+		Assert.That(blob, Is.EqualTo([0x42, 0x51, 0x0A, 0x54]));
+	}
+
+	[Test]
+	public void FormatEmpty()
+	{
+		Assert.That(BinaryProcessor.Format([]), Is.SameAs(string.Empty));
+	}
+
+	[Test]
+	public void FormatSingle()
+	{
+		Assert.That(BinaryProcessor.Format([0x42]), Is.EqualTo("42"));
+	}
+
+	[Test]
+	public void FormatQuad()
+	{
+		Assert.That(BinaryProcessor.Format([0x01, 0x23, 0x45, 0x67]), Is.EqualTo("01 23 45 67"));
+	}
+
+	[Test]
+	public void FormatLine()
+	{
+		const string Expected =
+			"""
+			00 01 02 03  04 05 06 07  08 09 0A 0B  0C 0D 0E 0F
+			""";
+
+		ReadOnlySpan<byte> blob =
+		[
+			0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07,  0x08, 0x09, 0x0A, 0x0B,  0x0C, 0x0D, 0x0E, 0x0F,
+		];
+
+		Assert.That(BinaryProcessor.Format(blob), Is.EqualTo(Expected));
+	}
+
+	[Test]
+	public void Format()
 	{
-		[TestCase("42 = 67")]
-		[TestCase("01 G0")]
-		[TestCase("0\u0011", TestName = "{m}(controlChar)")]
-		public void ParseInvalid(string text)
-		{
-			Assert.That(BinaryProcessor.Parse(text), Is.Null);
-		}
-
-		[Test]
-		public void ParseEmpty()
-		{
-			var blob = BinaryProcessor.Parse([]);
-			Assert.That(blob, Is.Empty);
-		}
-
-		[Test]
-		public void Parse()
-		{
-			var blob = BinaryProcessor.Parse("42 51 0A\r\n\r\n54".AsSpan());
-			Assert.That(blob, Is.EqualTo([0x42, 0x51, 0x0A, 0x54]));
-		}
-
-		[Test]
-		public void ParseLowercase()
-		{
-			var blob = BinaryProcessor.Parse("ab cd ef".AsSpan());
-			Assert.That(blob, Is.EqualTo([0xAB, 0xCD, 0xEF]));
-		}
-
-		[Test]
-		public void ParseUppercase()
-		{
-			var blob = BinaryProcessor.Parse("AB CD EF".AsSpan());
-			Assert.That(blob, Is.EqualTo([0xAB, 0xCD, 0xEF]));
-		}
-
-		[Test]
-		public void ParseHalfByte()
-		{
-			var blob = BinaryProcessor.Parse("4".AsSpan());
-			Assert.That(blob, Is.EqualTo([0x40]));
-		}
-
-		[Test]
-		public void ParseComments()
-		{
-			var blob = BinaryProcessor.Parse("42 51 0A // 05\r\n\r\n54".AsSpan());
-			Assert.That(blob, Is.EqualTo([0x42, 0x51, 0x0A, 0x54]));
-		}
-
-		[Test]
-		public void FormatEmpty()
-		{
-			Assert.That(BinaryProcessor.Format([]), Is.SameAs(string.Empty));
-		}
-
-		[Test]
-		public void FormatSingle()
-		{
-			Assert.That(BinaryProcessor.Format([0x42]), Is.EqualTo("42"));
-		}
-
-		[Test]
-		public void FormatQuad()
-		{
-			Assert.That(BinaryProcessor.Format([0x01, 0x23, 0x45, 0x67]), Is.EqualTo("01 23 45 67"));
-		}
-
-		[Test]
-		public void FormatLine()
-		{
-			const string Expected =
-				"""
-				00 01 02 03  04 05 06 07  08 09 0A 0B  0C 0D 0E 0F
-				""";
-
-			ReadOnlySpan<byte> blob =
-			[
-				0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07,  0x08, 0x09, 0x0A, 0x0B,  0x0C, 0x0D, 0x0E, 0x0F,
-			];
-
-			Assert.That(BinaryProcessor.Format(blob), Is.EqualTo(Expected));
-		}
-
-		[Test]
-		public void Format()
-		{
-			const string Expected =
-				"""
-				00 01 02 03  04 05 06 07  08 09 0A 0B  0C 0D 0E 0F
-				10 11 12 13  14 15 16 17  18 19 1A 1B  1C 1D 1E 1F
-				20
-				""";
-
-			ReadOnlySpan<byte> blob =
-			[
-				0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07,  0x08, 0x09, 0x0A, 0x0B,  0x0C, 0x0D, 0x0E, 0x0F,
-				0x10, 0x11, 0x12, 0x13,  0x14, 0x15, 0x16, 0x17,  0x18, 0x19, 0x1A, 0x1B,  0x1C, 0x1D, 0x1E, 0x1F,
-				0x20,
-			];
-
-			Assert.That(BinaryProcessor.Format(blob), Is.EqualTo(Expected));
-		}
+		const string Expected =
+			"""
+			00 01 02 03  04 05 06 07  08 09 0A 0B  0C 0D 0E 0F
+			10 11 12 13  14 15 16 17  18 19 1A 1B  1C 1D 1E 1F
+			20
+			""";
+
+		ReadOnlySpan<byte> blob =
+		[
+			0x00, 0x01, 0x02, 0x03,  0x04, 0x05, 0x06, 0x07,  0x08, 0x09, 0x0A, 0x0B,  0x0C, 0x0D, 0x0E, 0x0F,
+			0x10, 0x11, 0x12, 0x13,  0x14, 0x15, 0x16, 0x17,  0x18, 0x19, 0x1A, 0x1B,  0x1C, 0x1D, 0x1E, 0x1F,
+			0x20,
+		];
+
+		Assert.That(BinaryProcessor.Format(blob), Is.EqualTo(Expected));
 	}
 }
diff --git a/src/MethodCheck.Test/Data/ILRangeTest.cs b/src/MethodCheck.Test/Data/ILRangeTest.cs
index 60ee547..409216a 100644
--- a/src/MethodCheck.Test/Data/ILRangeTest.cs
+++ b/src/MethodCheck.Test/Data/ILRangeTest.cs
@@ -2,31 +2,30 @@
 using MethodCheck.Core.Data;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+class ILRangeTest
 {
-	[TestFixture]
-	class ILRangeTest
-	{
-		[TestCase(10, 1, ExpectedResult = "IL_000A (1)")]
-		[TestCase(1, 10, ExpectedResult = "IL_0001 (10)")]
-		public string Format(int start, int length) => new ILRange(start, length).ToString();
+	[TestCase(10, 1, ExpectedResult = "IL_000A (1)")]
+	[TestCase(1, 10, ExpectedResult = "IL_0001 (10)")]
+	public string Format(int start, int length) => new ILRange(start, length).ToString();
 
-		[TestCase(5, 10, ExpectedResult = true, TestName = "{m}_Exact")]
-		[TestCase(5, 1, ExpectedResult = true, TestName = "{m}_InsideStart")]
-		[TestCase(14, 1, ExpectedResult = true, TestName = "{m}_InsideEnd")]
-		[TestCase(4, 2, ExpectedResult = false, TestName = "{m}_OverlapStart")]
-		[TestCase(14, 2, ExpectedResult = false, TestName = "{m}_OverlapEnd")]
-		[TestCase(4, 1, ExpectedResult = false, TestName = "{m}_Prologue")]
-		[TestCase(15, 1, ExpectedResult = false, TestName = "{m}_Epilogue")]
-		public bool Contains(int start, int length) => new ILRange(5, 10).Contains(new ILRange(start, length));
+	[TestCase(5, 10, ExpectedResult = true, TestName = "{m}_Exact")]
+	[TestCase(5, 1, ExpectedResult = true, TestName = "{m}_InsideStart")]
+	[TestCase(14, 1, ExpectedResult = true, TestName = "{m}_InsideEnd")]
+	[TestCase(4, 2, ExpectedResult = false, TestName = "{m}_OverlapStart")]
+	[TestCase(14, 2, ExpectedResult = false, TestName = "{m}_OverlapEnd")]
+	[TestCase(4, 1, ExpectedResult = false, TestName = "{m}_Prologue")]
+	[TestCase(15, 1, ExpectedResult = false, TestName = "{m}_Epilogue")]
+	public bool Contains(int start, int length) => new ILRange(5, 10).Contains(new ILRange(start, length));
 
-		[TestCase(5, 10, ExpectedResult = true, TestName = "{m}_Exact")]
-		[TestCase(5, 1, ExpectedResult = true, TestName = "{m}_InsideStart")]
-		[TestCase(14, 1, ExpectedResult = true, TestName = "{m}_InsideEnd")]
-		[TestCase(4, 2, ExpectedResult = true, TestName = "{m}_OverlapStart")]
-		[TestCase(14, 2, ExpectedResult = true, TestName = "{m}_OverlapEnd")]
-		[TestCase(4, 1, ExpectedResult = false, TestName = "{m}_Prologue")]
-		[TestCase(15, 1, ExpectedResult = false, TestName = "{m}_Epilogue")]
-		public bool Overlaps(int start, int length) => new ILRange(5, 10).Overlaps(new ILRange(start, length));
-	}
+	[TestCase(5, 10, ExpectedResult = true, TestName = "{m}_Exact")]
+	[TestCase(5, 1, ExpectedResult = true, TestName = "{m}_InsideStart")]
+	[TestCase(14, 1, ExpectedResult = true, TestName = "{m}_InsideEnd")]
+	[TestCase(4, 2, ExpectedResult = true, TestName = "{m}_OverlapStart")]
+	[TestCase(14, 2, ExpectedResult = true, TestName = "{m}_OverlapEnd")]
+	[TestCase(4, 1, ExpectedResult = false, TestName = "{m}_Prologue")]
+	[TestCase(15, 1, ExpectedResult = false, TestName = "{m}_Epilogue")]
+	public bool Overlaps(int start, int length) => new ILRange(5, 10).Overlaps(new ILRange(start, length));
 }
diff --git a/src/MethodCheck.Test/Data/LabelTest.cs b/src/MethodCheck.Test/Data/LabelTest.cs
index db8958d..50d9c20 100644
--- a/src/MethodCheck.Test/Data/LabelTest.cs
+++ b/src/MethodCheck.Test/Data/LabelTest.cs
@@ -2,14 +2,13 @@
 using MethodCheck.Core.Data;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+class LabelTest
 {
-	[TestFixture]
-	class LabelTest
-	{
-		[TestCase(0, ExpectedResult = "IL_0000")]
-		[TestCase(10, ExpectedResult = "IL_000A")]
-		[TestCase(32, ExpectedResult = "IL_0020")]
-		public string Format(int offset) => new Label(offset).ToString();
-	}
+	[TestCase(0, ExpectedResult = "IL_0000")]
+	[TestCase(10, ExpectedResult = "IL_000A")]
+	[TestCase(32, ExpectedResult = "IL_0020")]
+	public string Format(int offset) => new Label(offset).ToString();
 }
diff --git a/src/MethodCheck.Test/MetadataTokenTest.cs b/src/MethodCheck.Test/MetadataTokenTest.cs
index 1c2b84f..0d2e51e 100644
--- a/src/MethodCheck.Test/MetadataTokenTest.cs
+++ b/src/MethodCheck.Test/MetadataTokenTest.cs
@@ -2,13 +2,12 @@
 using MethodCheck.Core.Data;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+class MetadataTokenTest
 {
-	[TestFixture]
-	class MetadataTokenTest
-	{
-		[TestCase(0, ExpectedResult = "00000000")]
-		[TestCase(0x0A000042, ExpectedResult = "0A000042")]
-		public string Format(int value) => new MetadataToken(value).ToString();
-	}
+	[TestCase(0, ExpectedResult = "00000000")]
+	[TestCase(0x0A000042, ExpectedResult = "0A000042")]
+	public string Format(int value) => new MetadataToken(value).ToString();
 }
diff --git a/src/MethodCheck.Test/MethodFormatterTest.cs b/src/MethodCheck.Test/MethodFormatterTest.cs
index 12f6582..b3f59d6 100644
--- a/src/MethodCheck.Test/MethodFormatterTest.cs
+++ b/src/MethodCheck.Test/MethodFormatterTest.cs
@@ -9,71 +9,70 @@
 using MethodCheck.Core.Parsing;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+partial class MethodFormatterTest
 {
-	[TestFixture]
-	partial class MethodFormatterTest
+	[Test]
+	public void ParseAndFormat([ValueSource(nameof(Samples))] string name)
 	{
-		[Test]
-		public void ParseAndFormat([ValueSource(nameof(Samples))] string name)
-		{
-			var source = Load(name);
-			var match = Splitter().Match(source);
-			Assert.That(match.Success, Is.True);
-
-			var group = match.Groups["splitter"];
-			var blob = BinaryProcessor.Parse(source.AsSpan(0, group.Index));
+		var source = Load(name);
+		var match = Splitter().Match(source);
+		Assert.That(match.Success, Is.True);
 
-			MethodData? data;
-			bool sectioned;
+		var group = match.Groups["splitter"];
+		var blob = BinaryProcessor.Parse(source.AsSpan(0, group.Index));
 
-			if (name.StartsWith("Body.", StringComparison.InvariantCulture))
-			{
-				data = MethodParser.ParseBody(blob);
-				sectioned = false;
-			}
-			else if (name.StartsWith("IL.", StringComparison.InvariantCulture))
-			{
-				data = MethodParser.ParseIL(blob);
-				sectioned = false;
-			}
-			else if (name.StartsWith("BodySection.", StringComparison.InvariantCulture))
-			{
-				data = MethodParser.ParseBody(blob);
-				sectioned = true;
-			}
-			else
-			{
-				throw new ArgumentException("Could not identify format from resource name.", nameof(name));
-			}
+		MethodData? data;
+		bool sectioned;
 
-			var actual = data == null ? null : MethodFormatter.Format(data, sectioned);
-			var expected = source.Substring(group.Index + group.Length);
-
-			Assert.That(actual, Is.EqualTo(expected));
+		if (name.StartsWith("Body.", StringComparison.InvariantCulture))
+		{
+			data = MethodParser.ParseBody(blob);
+			sectioned = false;
 		}
-
-		protected static IEnumerable<string> Samples
+		else if (name.StartsWith("IL.", StringComparison.InvariantCulture))
 		{
-			get
-			{
-				return
-					from resource in typeof(MethodFormatterTest).Assembly.GetManifestResourceNames()
-					where resource.StartsWith(ResourcePrefix, StringComparison.InvariantCulture)
-					select resource.Substring(ResourcePrefix.Length);
-			}
+			data = MethodParser.ParseIL(blob);
+			sectioned = false;
 		}
-
-		static string Load(string name)
+		else if (name.StartsWith("BodySection.", StringComparison.InvariantCulture))
 		{
-			using var stream = typeof(MethodFormatterTest).Assembly.GetManifestResourceStream(ResourcePrefix + name);
-			using var reader = new StreamReader(stream!);
-			return reader.ReadToEnd();
+			data = MethodParser.ParseBody(blob);
+			sectioned = true;
+		}
+		else
+		{
+			throw new ArgumentException("Could not identify format from resource name.", nameof(name));
 		}
 
-		const string ResourcePrefix = "MethodCheck.Test.Samples.";
+		var actual = data == null ? null : MethodFormatter.Format(data, sectioned);
+		var expected = source.Substring(group.Index + group.Length);
 
-		[GeneratedRegex(@"(?<splitter>===+\r?\n)", RegexOptions.ExplicitCapture | RegexOptions.Multiline)]
-		private static partial Regex Splitter();
+		Assert.That(actual, Is.EqualTo(expected));
 	}
+
+	protected static IEnumerable<string> Samples
+	{
+		get
+		{
+			return
+				from resource in typeof(MethodFormatterTest).Assembly.GetManifestResourceNames()
+				where resource.StartsWith(ResourcePrefix, StringComparison.InvariantCulture)
+				select resource.Substring(ResourcePrefix.Length);
+		}
+	}
+
+	static string Load(string name)
+	{
+		using var stream = typeof(MethodFormatterTest).Assembly.GetManifestResourceStream(ResourcePrefix + name);
+		using var reader = new StreamReader(stream!);
+		return reader.ReadToEnd();
+	}
+
+	const string ResourcePrefix = "MethodCheck.Test.Samples.";
+
+	[GeneratedRegex(@"(?<splitter>===+\r?\n)", RegexOptions.ExplicitCapture | RegexOptions.Multiline)]
+	private static partial Regex Splitter();
 }
diff --git a/src/MethodCheck.Test/SectionFactoryTest.cs b/src/MethodCheck.Test/SectionFactoryTest.cs
index 0b382e2..df4b7b1 100644
--- a/src/MethodCheck.Test/SectionFactoryTest.cs
+++ b/src/MethodCheck.Test/SectionFactoryTest.cs
@@ -8,373 +8,372 @@
 using MethodCheck.Core.Data.Sections;
 using NUnit.Framework;
 
-namespace MethodCheck.Test
+namespace MethodCheck.Test;
+
+[TestFixture]
+class SectionFactoryTest
 {
-	[TestFixture]
-	class SectionFactoryTest
+	[Test]
+	public void Empty()
 	{
-		[Test]
-		public void Empty()
-		{
-			const string Expected =
-				"""
-				<il range="IL_0000 (10)" />
-				""";
+		const string Expected =
+			"""
+			<il range="IL_0000 (10)" />
+			""";
 
-			var section = SectionFactory.Create(new ILRange(0, 10), Array.Empty<ExceptionHandler>());
+		var section = SectionFactory.Create(new ILRange(0, 10), Array.Empty<ExceptionHandler>());
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void Catch()
+	[Test]
+	public void Catch()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (10)">
+				<try.block>
+					<il range="IL_0000 (6)" />
+				</try.block>
+				<handler type="Clause" exception="02000010">
+					<il range="IL_0006 (4)" />
+				</handler>
+			</try>
+			""";
+
+		var handlers = new[]
 		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (10)">
-					<try.block>
-						<il range="IL_0000 (6)" />
-					</try.block>
-					<handler type="Clause" exception="02000010">
-						<il range="IL_0006 (4)" />
-					</handler>
-				</try>
-				""";
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 6), new ILRange(6, 4), 0x02000010),
+		};
 
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 6), new ILRange(6, 4), 0x02000010),
-			};
+		var section = SectionFactory.Create(new ILRange(0, 10), handlers);
 
-			var section = SectionFactory.Create(new ILRange(0, 10), handlers);
-
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
-
-		[Test]
-		public void Finally()
-		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (10)">
-					<try.block>
-						<il range="IL_0000 (6)" />
-					</try.block>
-					<handler type="Finally">
-						<il range="IL_0006 (4)" />
-					</handler>
-				</try>
-				""";
-
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 6), new ILRange(6, 4), 0),
-			};
-
-			var section = SectionFactory.Create(new ILRange(0, 10), handlers);
-
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void Filter()
+	[Test]
+	public void Finally()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (10)">
+				<try.block>
+					<il range="IL_0000 (6)" />
+				</try.block>
+				<handler type="Finally">
+					<il range="IL_0006 (4)" />
+				</handler>
+			</try>
+			""";
+
+		var handlers = new[]
 		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (12)">
-					<try.block>
-						<il range="IL_0000 (3)" />
-					</try.block>
-					<handler type="Filter">
-						<filter>
-							<il range="IL_0003 (4)" />
-						</filter>
-						<il range="IL_0007 (5)" />
-					</handler>
-				</try>
-				""";
-
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Filter, new ILRange(0, 3), new ILRange(7, 5), 3),
-			};
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 6), new ILRange(6, 4), 0),
+		};
 
-			var section = SectionFactory.Create(new ILRange(0, 12), handlers);
+		var section = SectionFactory.Create(new ILRange(0, 10), handlers);
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void OverlappingTry()
+	[Test]
+	public void Filter()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (12)">
+				<try.block>
+					<il range="IL_0000 (3)" />
+				</try.block>
+				<handler type="Filter">
+					<filter>
+						<il range="IL_0003 (4)" />
+					</filter>
+					<il range="IL_0007 (5)" />
+				</handler>
+			</try>
+			""";
+
+		var handlers = new[]
 		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (10)">
-					<try.block>
-						<il range="IL_0000 (2)" />
-					</try.block>
-					<handler type="Clause" exception="02000011">
-						<il range="IL_0002 (4)" />
-					</handler>
-					<handler type="Clause" exception="02000012">
-						<il range="IL_0006 (4)" />
-					</handler>
-				</try>
-				""";
-
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 2), new ILRange(2, 4), 0x02000011),
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 2), new ILRange(6, 4), 0x02000012),
-			};
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Filter, new ILRange(0, 3), new ILRange(7, 5), 3),
+		};
 
-			var section = SectionFactory.Create(new ILRange(0, 10), handlers);
+		var section = SectionFactory.Create(new ILRange(0, 12), handlers);
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void Nested()
+	[Test]
+	public void OverlappingTry()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (10)">
+				<try.block>
+					<il range="IL_0000 (2)" />
+				</try.block>
+				<handler type="Clause" exception="02000011">
+					<il range="IL_0002 (4)" />
+				</handler>
+				<handler type="Clause" exception="02000012">
+					<il range="IL_0006 (4)" />
+				</handler>
+			</try>
+			""";
+
+		var handlers = new[]
 		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (20)">
-					<try.block>
-						<try range="IL_0000 (10)">
-							<try.block>
-								<il range="IL_0000 (5)" />
-							</try.block>
-							<handler type="Clause" exception="02000010">
-								<il range="IL_0005 (5)" />
-							</handler>
-						</try>
-					</try.block>
-					<handler type="Finally">
-						<try range="IL_000A (10)">
-							<try.block>
-								<il range="IL_000A (5)" />
-							</try.block>
-							<handler type="Clause" exception="02000010">
-								<il range="IL_000F (5)" />
-							</handler>
-						</try>
-					</handler>
-				</try>
-				""";
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 2), new ILRange(2, 4), 0x02000011),
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 2), new ILRange(6, 4), 0x02000012),
+		};
 
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 5), new ILRange(5, 5), 0x02000010),
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(10, 5), new ILRange(15, 5), 0x02000010),
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 10), new ILRange(10, 10), 0),
-			};
-
-			var section = SectionFactory.Create(new ILRange(0, 20), handlers);
+		var section = SectionFactory.Create(new ILRange(0, 10), handlers);
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void Sequence()
-		{
-			const string Expected =
-				"""
-				<seq range="IL_0000 (22)">
-					<il range="IL_0000 (2)" />
-					<try range="IL_0002 (8)">
+	[Test]
+	public void Nested()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (20)">
+				<try.block>
+					<try range="IL_0000 (10)">
 						<try.block>
-							<il range="IL_0002 (4)" />
+							<il range="IL_0000 (5)" />
 						</try.block>
 						<handler type="Clause" exception="02000010">
-							<il range="IL_0006 (4)" />
+							<il range="IL_0005 (5)" />
 						</handler>
 					</try>
-					<il range="IL_000A (2)" />
-					<try range="IL_000C (8)">
+				</try.block>
+				<handler type="Finally">
+					<try range="IL_000A (10)">
 						<try.block>
-							<il range="IL_000C (4)" />
+							<il range="IL_000A (5)" />
 						</try.block>
 						<handler type="Clause" exception="02000010">
-							<il range="IL_0010 (4)" />
+							<il range="IL_000F (5)" />
 						</handler>
 					</try>
-					<il range="IL_0014 (2)" />
-				</seq>
-				""";
+				</handler>
+			</try>
+			""";
 
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 4), 0x02000010),
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(12, 4), new ILRange(16, 4), 0x02000010),
-			};
+		var handlers = new[]
+		{
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(0, 5), new ILRange(5, 5), 0x02000010),
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(10, 5), new ILRange(15, 5), 0x02000010),
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 10), new ILRange(10, 10), 0),
+		};
 
-			var section = SectionFactory.Create(new ILRange(0, 22), handlers);
+		var section = SectionFactory.Create(new ILRange(0, 20), handlers);
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[Test]
-		public void NestedSequence()
-		{
-			const string Expected =
-				"""
-				<try range="IL_0000 (10)">
+	[Test]
+	public void Sequence()
+	{
+		const string Expected =
+			"""
+			<seq range="IL_0000 (22)">
+				<il range="IL_0000 (2)" />
+				<try range="IL_0002 (8)">
 					<try.block>
-						<seq range="IL_0000 (8)">
-							<il range="IL_0000 (2)" />
-							<try range="IL_0002 (4)">
-								<try.block>
-									<il range="IL_0002 (2)" />
-								</try.block>
-								<handler type="Clause" exception="02000010">
-									<il range="IL_0004 (2)" />
-								</handler>
-							</try>
-							<il range="IL_0006 (2)" />
-						</seq>
+						<il range="IL_0002 (4)" />
+					</try.block>
+					<handler type="Clause" exception="02000010">
+						<il range="IL_0006 (4)" />
+					</handler>
+				</try>
+				<il range="IL_000A (2)" />
+				<try range="IL_000C (8)">
+					<try.block>
+						<il range="IL_000C (4)" />
 					</try.block>
-					<handler type="Finally">
-						<il range="IL_0008 (2)" />
+					<handler type="Clause" exception="02000010">
+						<il range="IL_0010 (4)" />
 					</handler>
 				</try>
-				""";
+				<il range="IL_0014 (2)" />
+			</seq>
+			""";
 
-			var handlers = new[]
-			{
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 2), new ILRange(4, 2), 0x02000010),
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 8), new ILRange(8, 2), 0),
-			};
+		var handlers = new[]
+		{
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 4), 0x02000010),
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(12, 4), new ILRange(16, 4), 0x02000010),
+		};
 
-			var section = SectionFactory.Create(new ILRange(0, 10), handlers);
+		var section = SectionFactory.Create(new ILRange(0, 22), handlers);
 
-			Assert.That(Format(section), Is.EqualTo(Expected));
-		}
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
 
-		[TestCaseSource(nameof(InvalidHandlers))]
-		public void InvalidHandlerConfigurations(ExceptionHandler[] handlers)
+	[Test]
+	public void NestedSequence()
+	{
+		const string Expected =
+			"""
+			<try range="IL_0000 (10)">
+				<try.block>
+					<seq range="IL_0000 (8)">
+						<il range="IL_0000 (2)" />
+						<try range="IL_0002 (4)">
+							<try.block>
+								<il range="IL_0002 (2)" />
+							</try.block>
+							<handler type="Clause" exception="02000010">
+								<il range="IL_0004 (2)" />
+							</handler>
+						</try>
+						<il range="IL_0006 (2)" />
+					</seq>
+				</try.block>
+				<handler type="Finally">
+					<il range="IL_0008 (2)" />
+				</handler>
+			</try>
+			""";
+
+		var handlers = new[]
 		{
-			Assert.That(
-				() => SectionFactory.Create(new ILRange(0, 10), handlers),
-				Throws.InstanceOf<CannotGenerateSectionException>());
-		}
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 2), new ILRange(4, 2), 0x02000010),
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Finally, new ILRange(0, 8), new ILRange(8, 2), 0),
+		};
 
-		protected static IEnumerable<TestCaseData> InvalidHandlers()
-		{
-			const int ExceptionType = 0x02000010;
+		var section = SectionFactory.Create(new ILRange(0, 10), handlers);
+
+		Assert.That(Format(section), Is.EqualTo(Expected));
+	}
+
+	[TestCaseSource(nameof(InvalidHandlers))]
+	public void InvalidHandlerConfigurations(ExceptionHandler[] handlers)
+	{
+		Assert.That(
+			() => SectionFactory.Create(new ILRange(0, 10), handlers),
+			Throws.InstanceOf<CannotGenerateSectionException>());
+	}
 
-			var baseHandler = new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 2), ExceptionType);
+	protected static IEnumerable<TestCaseData> InvalidHandlers()
+	{
+		const int ExceptionType = 0x02000010;
 
-			yield return Data(
-				"Not fully contained.",
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 2), new ILRange(8, 2), ExceptionType),
-				baseHandler);
+		var baseHandler = new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 2), ExceptionType);
 
-			yield return Data(
-				"Non contiguous handlers.",
-				baseHandler,
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(9, 1), ExceptionType));
+		yield return Data(
+			"Not fully contained.",
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 2), new ILRange(8, 2), ExceptionType),
+			baseHandler);
 
-			yield return Data(
-				"Handler extends outside bounds.",
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 5), ExceptionType));
+		yield return Data(
+			"Non contiguous handlers.",
+			baseHandler,
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(9, 1), ExceptionType));
 
-			yield return Data(
-				"Try outside bounds.",
-				new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(10, 2), new ILRange(12, 2), ExceptionType));
+		yield return Data(
+			"Handler extends outside bounds.",
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(2, 4), new ILRange(6, 5), ExceptionType));
 
-			static TestCaseData Data(string name, params ExceptionHandler[] handlers)
-				=> new TestCaseData(new object[] { handlers }).SetName("{m}(" + name + ")");
-		}
+		yield return Data(
+			"Try outside bounds.",
+			new ExceptionHandler(ExceptionHandlingClauseOptions.Clause, new ILRange(10, 2), new ILRange(12, 2), ExceptionType));
+
+		static TestCaseData Data(string name, params ExceptionHandler[] handlers)
+			=> new TestCaseData(new object[] { handlers }).SetName("{m}(" + name + ")");
+	}
 
-		static string Format(BaseSection section)
+	static string Format(BaseSection section)
+	{
+		var settings = new XmlWriterSettings()
 		{
-			var settings = new XmlWriterSettings()
-			{
-				Indent = true,
-				IndentChars = "\t",
-				OmitXmlDeclaration = true,
-			};
-
-			using var writer = new StringWriter();
-			using var xmlWriter = XmlWriter.Create(writer, settings);
-			Write(xmlWriter, section);
-			xmlWriter.Flush();
-			return writer.ToString();
-		}
+			Indent = true,
+			IndentChars = "\t",
+			OmitXmlDeclaration = true,
+		};
+
+		using var writer = new StringWriter();
+		using var xmlWriter = XmlWriter.Create(writer, settings);
+		Write(xmlWriter, section);
+		xmlWriter.Flush();
+		return writer.ToString();
+	}
 
-		static void Write(XmlWriter writer, BaseSection section)
+	static void Write(XmlWriter writer, BaseSection section)
+	{
+		switch (section)
 		{
-			switch (section)
-			{
-				case ILSection ilSection:
-					Write(writer, ilSection);
-					break;
+			case ILSection ilSection:
+				Write(writer, ilSection);
+				break;
 
-				case SequenceSection sequenceSection:
-					Write(writer, sequenceSection);
-					break;
+			case SequenceSection sequenceSection:
+				Write(writer, sequenceSection);
+				break;
 
-				case TryBlockSection tryBlock:
-					Write(writer, tryBlock);
-					break;
-			}
+			case TryBlockSection tryBlock:
+				Write(writer, tryBlock);
+				break;
 		}
+	}
+
+	static void Write(XmlWriter writer, ILSection section)
+	{
+		writer.WriteStartElement("il");
+		AppendRangeAttributes(writer, section);
+		writer.WriteEndElement();
+	}
+
+	static void Write(XmlWriter writer, SequenceSection section)
+	{
+		writer.WriteStartElement("seq");
+		AppendRangeAttributes(writer, section);
 
-		static void Write(XmlWriter writer, ILSection section)
+		foreach (var seq in section.Sections)
 		{
-			writer.WriteStartElement("il");
-			AppendRangeAttributes(writer, section);
-			writer.WriteEndElement();
+			Write(writer, seq);
 		}
 
-		static void Write(XmlWriter writer, SequenceSection section)
+		writer.WriteEndElement();
+	}
+
+	static void Write(XmlWriter writer, TryBlockSection section)
+	{
+		writer.WriteStartElement("try");
+		AppendRangeAttributes(writer, section);
+		writer.WriteStartElement("try.block");
+		Write(writer, section.TryBlock);
+		writer.WriteEndElement();
+
+		foreach (var handler in section.HandlerBlocks)
 		{
-			writer.WriteStartElement("seq");
-			AppendRangeAttributes(writer, section);
+			writer.WriteStartElement("handler");
+			writer.WriteAttributeString("type", handler.Type.ToString());
 
-			foreach (var seq in section.Sections)
+			if (handler.ExceptionType != default)
 			{
-				Write(writer, seq);
+				writer.WriteAttributeString("exception", handler.ExceptionType.ToString());
 			}
 
-			writer.WriteEndElement();
-		}
-
-		static void Write(XmlWriter writer, TryBlockSection section)
-		{
-			writer.WriteStartElement("try");
-			AppendRangeAttributes(writer, section);
-			writer.WriteStartElement("try.block");
-			Write(writer, section.TryBlock);
-			writer.WriteEndElement();
-
-			foreach (var handler in section.HandlerBlocks)
+			if (handler.FilterSection != null)
 			{
-				writer.WriteStartElement("handler");
-				writer.WriteAttributeString("type", handler.Type.ToString());
-
-				if (handler.ExceptionType != default)
-				{
-					writer.WriteAttributeString("exception", handler.ExceptionType.ToString());
-				}
-
-				if (handler.FilterSection != null)
-				{
-					writer.WriteStartElement("filter");
-					Write(writer, handler.FilterSection);
-					writer.WriteEndElement();
-				}
-
-				Write(writer, handler.HandlerSection);
+				writer.WriteStartElement("filter");
+				Write(writer, handler.FilterSection);
 				writer.WriteEndElement();
 			}
 
+			Write(writer, handler.HandlerSection);
 			writer.WriteEndElement();
 		}
 
-		static void AppendRangeAttributes(XmlWriter writer, BaseSection ilSection)
-		{
-			writer.WriteAttributeString("range", ilSection.Range.ToString());
-		}
+		writer.WriteEndElement();
+	}
+
+	static void AppendRangeAttributes(XmlWriter writer, BaseSection ilSection)
+	{
+		writer.WriteAttributeString("range", ilSection.Range.ToString());
 	}
 }
diff --git a/src/MethodCheck/App.xaml.cs b/src/MethodCheck/App.xaml.cs
index ea76272..f32df22 100644
--- a/src/MethodCheck/App.xaml.cs
+++ b/src/MethodCheck/App.xaml.cs
@@ -1,9 +1,8 @@
 // Copyright (c) Brian Reichle.  All Rights Reserved.  Licensed under the MIT License.  See License.txt in the project root for license information.
 using System.Windows;
 
-namespace MethodCheck
+namespace MethodCheck;
+
+public partial class App : Application
 {
-	public partial class App : Application
-	{
-	}
 }
diff --git a/src/MethodCheck/MainWindow.xaml.cs b/src/MethodCheck/MainWindow.xaml.cs
index c6bfdca..d785ef4 100644
--- a/src/MethodCheck/MainWindow.xaml.cs
+++ b/src/MethodCheck/MainWindow.xaml.cs
@@ -6,86 +6,85 @@
 using MethodCheck.Core.Data;
 using MethodCheck.Core.Parsing;
 
-namespace MethodCheck
+namespace MethodCheck;
+
+public partial class MainWindow : Window
 {
-	public partial class MainWindow : Window
+	public static readonly RoutedCommand Run = new(nameof(Run), typeof(MainWindow));
+	public static readonly RoutedCommand SetFocus = new(nameof(SetFocus), typeof(MainWindow));
+
+	public MainWindow()
 	{
-		public static readonly RoutedCommand Run = new(nameof(Run), typeof(MainWindow));
-		public static readonly RoutedCommand SetFocus = new(nameof(SetFocus), typeof(MainWindow));
+		InitializeComponent();
 
-		public MainWindow()
+		Loaded += (sender, e) =>
 		{
-			InitializeComponent();
+			var window = (MainWindow)sender;
+			window.BytesTextBox?.Focus();
+		};
+	}
 
-			Loaded += (sender, e) =>
-			{
-				var window = (MainWindow)sender;
-				window.BytesTextBox?.Focus();
-			};
-		}
+	protected override void OnActivated(EventArgs e)
+	{
+		base.OnActivated(e);
 
-		protected override void OnActivated(EventArgs e)
+		if (IsFocused && BytesTextBox != null)
 		{
-			base.OnActivated(e);
-
-			if (IsFocused && BytesTextBox != null)
-			{
-				BytesTextBox.Focus();
-			}
+			BytesTextBox.Focus();
 		}
+	}
 
-		void BytesTextBox_LostFocus(object sender, RoutedEventArgs e)
-		{
-			DoRun();
-		}
+	void BytesTextBox_LostFocus(object sender, RoutedEventArgs e)
+	{
+		DoRun();
+	}
 
-		void CloseExecuted(object sender, ExecutedRoutedEventArgs e)
-		{
-			Close();
-		}
+	void CloseExecuted(object sender, ExecutedRoutedEventArgs e)
+	{
+		Close();
+	}
 
-		void RunExecuted(object sender, ExecutedRoutedEventArgs e)
-		{
-			DoRun();
-		}
+	void RunExecuted(object sender, ExecutedRoutedEventArgs e)
+	{
+		DoRun();
+	}
 
-		void SetFocusExecuted(object sender, ExecutedRoutedEventArgs e)
-		{
-			((FrameworkElement)e.Source).Focus();
-		}
+	void SetFocusExecuted(object sender, ExecutedRoutedEventArgs e)
+	{
+		((FrameworkElement)e.Source).Focus();
+	}
 
-		void DoRun()
-		{
-			var buffer = BinaryProcessor.Parse(BytesTextBox.Text.AsSpan());
+	void DoRun()
+	{
+		var buffer = BinaryProcessor.Parse(BytesTextBox.Text.AsSpan());
 
-			if (buffer != null)
-			{
-				BytesTextBox.Text = BinaryProcessor.Format(buffer);
+		if (buffer != null)
+		{
+			BytesTextBox.Text = BinaryProcessor.Format(buffer);
 
-				var data = Parse(buffer);
+			var data = Parse(buffer);
 
-				if (data != null)
-				{
-					var sectioned = ShowSectioned.IsChecked ?? false;
-					ILTextBox.Text = MethodFormatter.Format(data, sectioned);
-				}
+			if (data != null)
+			{
+				var sectioned = ShowSectioned.IsChecked ?? false;
+				ILTextBox.Text = MethodFormatter.Format(data, sectioned);
 			}
 		}
+	}
 
-		MethodData? Parse(ReadOnlySpan<byte> buffer)
+	MethodData? Parse(ReadOnlySpan<byte> buffer)
+	{
+		if (SourceTypeIL.IsChecked == true)
 		{
-			if (SourceTypeIL.IsChecked == true)
-			{
-				return MethodParser.ParseIL(buffer);
-			}
-			else if (SourceTypeBody.IsChecked == true)
-			{
-				return MethodParser.ParseBody(buffer);
-			}
-			else
-			{
-				return null;
-			}
+			return MethodParser.ParseIL(buffer);
+		}
+		else if (SourceTypeBody.IsChecked == true)
+		{
+			return MethodParser.ParseBody(buffer);
+		}
+		else
+		{
+			return null;
 		}
 	}
 }