diff --git a/Generator/Extensions.cs b/Generator/Extensions.cs
new file mode 100644
index 0000000..57aa30d
--- /dev/null
+++ b/Generator/Extensions.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+public static class Extensions
+{
+    public static string Joined<T>(this IEnumerable<T> source, string delimiter, Func<T, string>? selector = null)
+    {
+        if (source == null)
+        {
+            return "";
+        }
+
+        if (selector == null)
+        {
+            return string.Join(delimiter, source);
+        }
+
+        return string.Join(delimiter, source.Select(selector));
+    }
+
+    public static string Joined<T>(this IEnumerable<T> source, string delimiter, Func<T, int, string> selector)
+    {
+        if (source == null)
+        {
+            return "";
+        }
+
+        return string.Join(delimiter, source.Select(selector));
+    }
+
+    public static IEnumerable<T> ExceptSingle<T>(this IEnumerable<T> source, T single) =>
+        source.Except(Enumerable.Repeat(single, 1));
+
+    public static void AppendLineTo(this string? s, StringBuilder sb) => sb.AppendLine(s);
+}
diff --git a/Generator/FileContentGenerator.cs b/Generator/FileContentGenerator.cs
new file mode 100644
index 0000000..d1c8af1
--- /dev/null
+++ b/Generator/FileContentGenerator.cs
@@ -0,0 +1,308 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace Generator;
+
+public sealed class FileContentGenerator : IDisposable
+{
+    private delegate void ReadOnlySpanAction<T>(ReadOnlySpan<T> obj);
+    
+    private readonly bool _isStruct;
+    private readonly int _index;
+    private readonly StreamWriter _streamWriter;
+    private readonly string _className;
+    private readonly List<string> _genericArgs;
+    private readonly string _genericArg;
+
+    public FileContentGenerator(string path, bool isStruct, int index)
+    {
+        _isStruct = isStruct;
+        _index = index;
+        _streamWriter = new StreamWriter(path);
+        
+        _className = _isStruct ? "OneOf" : "OneOfBase";
+        _genericArgs = Enumerable.Range(0, _index).Select(e => $"T{e}").ToList();
+        _genericArg = _genericArgs.Joined(", ");
+    }
+
+    private string RangeJoined(string delimiter, Func<int, string> selector) =>
+        Enumerable.Range(0, _index).Joined(delimiter, selector);
+
+    private string IfStruct(string s, string s2 = "") => _isStruct ? s : s2;
+    
+    private static void ForEachCombination(
+        ReadOnlySpan<string> src, int k, ReadOnlySpanAction<int> action)
+    {
+        int n = src.Length;
+        if (k < 0 || k > n)
+        {
+            return;
+        }
+
+        // --- стековые буферы ---
+        Span<int> idx = k <= 64 ? stackalloc int[k] : new int[k];
+
+        // инициализируем первую комбинацию 0..k-1
+        for (int j = 0; j < k; j++)
+        {
+            idx[j] = j;
+        }
+
+        while (true)
+        {
+            action(idx); // ← обрабатываем без аллокации
+
+            // переходим к следующей комбинации
+            int i = k - 1;
+            while (i >= 0 && idx[i] == n - k + i)
+            {
+                i--;
+            }
+
+            if (i < 0)
+            {
+                break; // перебрали всё
+            }
+
+            idx[i]++;
+            for (int j = i + 1; j < k; j++)
+            {
+                idx[j] = idx[j - 1] + 1;
+            }
+        }
+    }
+
+    public void WriteContent()
+    {
+        _streamWriter.Write($@"using System;
+using static OneOf.Functions;
+
+namespace OneOf
+{{");
+        _streamWriter.Write(@$"
+    public {IfStruct("readonly struct", "class")} {_className}<{_genericArg}> : IOneOf
+    {{");
+        
+        _streamWriter.WriteLine($@"
+        {RangeJoined(@"
+        ", j => $"readonly T{j} _value{j};")}
+        readonly int _index;");
+        
+        _streamWriter.WriteLine(@$"
+        {IfStruct( // constructor
+            $@"OneOf(int index, {RangeJoined(", ", j => $"T{j} value{j} = default")})
+        {{
+            _index = index;
+            {RangeJoined(@"
+            ", j => $"_value{j} = value{j};")}
+        }}",
+            $@"protected OneOfBase(OneOf<{_genericArg}> input)
+        {{
+            _index = input.Index;
+            switch (_index)
+            {{
+                {RangeJoined($@"
+                ", j => $"case {j}: _value{j} = input.AsT{j}; break;")}
+                default: throw new InvalidOperationException();
+            }}
+        }}")}");
+
+        _streamWriter.WriteLine($@"
+        public object Value =>
+            _index switch
+            {{
+                {RangeJoined(@"
+                ", j => $"{j} => _value{j},")}
+                _ => throw new InvalidOperationException()
+            }};
+
+        public int Index => _index;");
+        
+        _streamWriter.WriteLine(@$"
+        {RangeJoined(@"
+        ", j => $"public bool IsT{j} => _index == {j};")}");
+        
+        _streamWriter.WriteLine(@$"
+        {RangeJoined(@"
+        ", j => $@"public T{j} AsT{j} =>
+            _index == {j} ?
+                _value{j} :
+                throw new InvalidOperationException($""Cannot return as T{j} as result is T{{_index}}"");")}");
+        
+        _streamWriter.WriteLine(@$"
+        {IfStruct(RangeJoined(@"
+        ", j => $"public static implicit operator {_className}<{_genericArg}>(T{j} t) => new {_className}<{_genericArg}>({j}, value{j}: t);"))}");
+        
+        if (_isStruct && _index > 1 && _index < 10)
+        {
+            for (int i = 2; i < _genericArgs.Count; i++)
+            {
+                ForEachCombination(CollectionsMarshal.AsSpan(_genericArgs), i, idx =>
+                {
+                    _streamWriter.Write($"        public static implicit operator {_className}<{_genericArg}>({_className}<");
+                    for (int j = 0; j < idx.Length; j++)
+                    {
+                        if (j != 0)
+                        {
+                            _streamWriter.Write(", ");
+                        }
+                        
+                        _streamWriter.Write(_genericArgs[idx[j]]);
+                    }
+
+                    _streamWriter.Write($"> subset) => subset.Match<{_className}<{_genericArg}>>(");
+                    
+                    for (int j = 0; j < idx.Length; j++)
+                    {
+                        if (j != 0)
+                        {
+                            _streamWriter.Write(", ");
+                        }
+                        
+                        _streamWriter.Write("x => x");
+                    }
+
+                    _streamWriter.WriteLine(");");
+                });
+            }
+        }
+        
+        _streamWriter.WriteLine($@"
+        public void Switch({RangeJoined(", ", e => $"Action<T{e}> f{e}")})
+        {{
+            {RangeJoined(@"
+            ", j => @$"if (_index == {j} && f{j} != null)
+            {{
+                f{j}(_value{j});
+                return;
+            }}")}
+            throw new InvalidOperationException();
+        }}");
+        
+        _streamWriter.WriteLine($@"
+        public TResult Match<TResult>({RangeJoined(", ", e => $"Func<T{e}, TResult> f{e}")})
+        {{
+            {RangeJoined(@"
+            ", j => $@"if (_index == {j} && f{j} != null)
+            {{
+                return f{j}(_value{j});
+            }}")}
+            throw new InvalidOperationException();
+        }}");
+
+        _streamWriter.WriteLine($@"
+        {IfStruct(_genericArgs.Joined(@"
+        ", bindToType => $@"public static OneOf<{_genericArgs.Joined(", ")}> From{bindToType}({bindToType} input) => input;"))}");
+        
+        _streamWriter.WriteLine($@"
+        {IfStruct(_genericArgs.Joined(@"
+            ", bindToType => {
+            var resultArgsPrinted = _genericArgs.Select(x => {
+                return x == bindToType ? "TResult" : x;
+            }).Joined(", ");
+            return $@"
+        public OneOf<{resultArgsPrinted}> Map{bindToType}<TResult>(Func<{bindToType}, TResult> mapFunc)
+        {{
+            if (mapFunc == null)
+            {{
+                throw new ArgumentNullException(nameof(mapFunc));
+            }}
+            return _index switch
+            {{
+                {_genericArgs.Joined(@"
+                ", (x, k) =>
+                    x == bindToType ?
+                        $"{k} => mapFunc(As{x})," :
+                        $"{k} => As{x},")}
+                _ => throw new InvalidOperationException()
+            }};
+        }}";
+        }))}");
+
+        if (_index > 1)
+        {
+            _streamWriter.WriteLine(RangeJoined(@"
+        ", j =>
+            {
+                var genericArgWithSkip = Enumerable.Range(0, _index).ExceptSingle(j).Joined(", ", e => $"T{e}");
+                var remainderType = _index == 2 ? genericArgWithSkip : $"OneOf<{genericArgWithSkip}>";
+                return $@"
+		public bool TryPickT{j}(out T{j} value, out {remainderType} remainder)
+		{{
+			value = IsT{j} ? AsT{j} : default;
+            remainder = _index switch
+            {{
+                {RangeJoined(@"
+                ", k =>
+                    k == j ?
+                        $"{k} => default," :
+                        $"{k} => AsT{k},")}
+                _ => throw new InvalidOperationException()
+            }};
+			return this.IsT{j};
+		}}";
+            }));
+        }
+        
+        _streamWriter.WriteLine($@"
+        bool Equals({_className}<{_genericArg}> other) =>
+            _index == other._index &&
+            _index switch
+            {{
+                {RangeJoined(@"
+                ", j => @$"{j} => Equals(_value{j}, other._value{j}),")}
+                _ => false
+            }};");
+        
+        _streamWriter.WriteLine($@"
+        public override bool Equals(object obj)
+        {{
+            if (ReferenceEquals(null, obj))
+            {{
+                return false;
+            }}
+
+            {IfStruct(
+                $"return obj is OneOf<{_genericArg}> o && Equals(o);",
+                $@"if (ReferenceEquals(this, obj)) {{
+                    return true;
+            }}
+
+            return obj is OneOfBase<{_genericArg}> o && Equals(o);"
+            )}
+        }}");
+        
+        _streamWriter.WriteLine($@"
+        public override string ToString() =>
+            _index switch {{
+                {RangeJoined(@"
+                ", j => $"{j} => FormatValue(_value{j}),")}
+                _ => throw new InvalidOperationException(""Unexpected index, which indicates a problem in the OneOf codegen."")
+            }};");
+        
+        _streamWriter.WriteLine($@"
+        public override int GetHashCode()
+        {{
+            unchecked
+            {{
+                int hashCode = _index switch
+                {{
+                    {RangeJoined(@"
+                    ", j => $"{j} => _value{j}?.GetHashCode(),")}
+                    _ => 0
+                }} ?? 0;
+                return (hashCode*397) ^ _index;
+            }}
+        }}
+    }}
+}}");
+    }
+
+    public void Dispose()
+    {
+        _streamWriter.Dispose();
+    }
+}
diff --git a/Generator/Program.cs b/Generator/Program.cs
index 4f04e2b..8dc9585 100644
--- a/Generator/Program.cs
+++ b/Generator/Program.cs
@@ -1,231 +1,35 @@
-using System.IO;
-using System.Text;
+using Generator;
 using static System.IO.Path;
 using static System.Reflection.Assembly;
-using static System.Linq.Enumerable;
-using System;
-using System.Collections.Generic;
 
 var sourceRoot = GetFullPath(Combine(GetDirectoryName(GetExecutingAssembly().Location)!, @"..\..\..\.."));
 
-for (var i = 1; i < 10; i++) {
-    var output = GetContent(true, i);
-    var outpath = Combine(sourceRoot, $"OneOf\\OneOfT{i - 1}.generated.cs");
-    File.WriteAllText(outpath, output);
-
-    var output2 = GetContent(false, i);
-    var outpath2 = Combine(sourceRoot, $"OneOf\\OneOfBaseT{i - 1}.generated.cs");
-    File.WriteAllText(outpath2, output2);
-}
-
-for (var i = 10; i < 33; i++) {
-    var output3 = GetContent(true, i);
-    var outpath3 = Combine(sourceRoot, $"OneOf.Extended\\OneOfT{i - 1}.generated.cs");
-    File.WriteAllText(outpath3, output3);
-
-    var output4 = GetContent(false, i);
-    var outpath4 = Combine(sourceRoot, $"OneOf.Extended\\OneOfBaseT{i - 1}.generated.cs");
-    File.WriteAllText(outpath4, output4);
-}
-
-string GetContent(bool isStruct, int i) {
-    string RangeJoined(string delimiter, Func<int, string> selector) => Range(0, i).Joined(delimiter, selector);
-    string IfStruct(string s, string s2 = "") => isStruct ? s : s2;
-
-    var className = isStruct ? "OneOf" : "OneOfBase";
-    var genericArgs = Range(0, i).Select(e => $"T{e}").ToList();
-    var genericArg = genericArgs.Joined(", ");
-    var sb = new StringBuilder();
-    
-    sb.Append(@$"using System;
-using static OneOf.Functions;
-
-namespace OneOf
-{{
-    public {IfStruct("readonly struct", "class")} {className}<{genericArg}> : IOneOf
-    {{
-        {RangeJoined(@"
-        ", j => $"readonly T{j} _value{j};")}
-        readonly int _index;
-
-        {IfStruct( // constructor
-        $@"OneOf(int index, {RangeJoined(", ", j => $"T{j} value{j} = default")})
-        {{
-            _index = index;
-            {RangeJoined(@"
-            ", j => $"_value{j} = value{j};")}
-        }}",
-        $@"protected OneOfBase(OneOf<{genericArg}> input)
-        {{
-            _index = input.Index;
-            switch (_index)
-            {{
-                {RangeJoined($@"
-                ", j => $"case {j}: _value{j} = input.AsT{j}; break;")}
-                default: throw new InvalidOperationException();
-            }}
-        }}"
-        )}
-
-        public object Value =>
-            _index switch
-            {{
-                {RangeJoined(@"
-                ", j => $"{j} => _value{j},")}
-                _ => throw new InvalidOperationException()
-            }};
-
-        public int Index => _index;
-
-        {RangeJoined(@"
-        ", j=> $"public bool IsT{j} => _index == {j};")}
-
-        {RangeJoined(@"
-        ", j => $@"public T{j} AsT{j} =>
-            _index == {j} ?
-                _value{j} :
-                throw new InvalidOperationException($""Cannot return as T{j} as result is T{{_index}}"");")}
-
-        {IfStruct(RangeJoined(@"
-        ", j => $"public static implicit operator {className}<{genericArg}>(T{j} t) => new {className}<{genericArg}>({j}, value{j}: t);"))}
-
-        public void Switch({RangeJoined(", ", e => $"Action<T{e}> f{e}")})
-        {{
-            {RangeJoined(@"
-            ", j => @$"if (_index == {j} && f{j} != null)
-            {{
-                f{j}(_value{j});
-                return;
-            }}")}
-            throw new InvalidOperationException();
-        }}
-
-        public TResult Match<TResult>({RangeJoined(", ", e => $"Func<T{e}, TResult> f{e}")})
-        {{
-            {RangeJoined(@"
-            ", j => $@"if (_index == {j} && f{j} != null)
-            {{
-                return f{j}(_value{j});
-            }}")}
-            throw new InvalidOperationException();
-        }}
-
-        {IfStruct(genericArgs.Joined(@"
-        ", bindToType => $@"public static OneOf<{genericArgs.Joined(", ")}> From{bindToType}({bindToType} input) => input;"))}
-
-        {IfStruct(genericArgs.Joined(@"
-            ", bindToType => {
-            var resultArgsPrinted = genericArgs.Select(x => {
-                return x == bindToType ? "TResult" : x;
-            }).Joined(", ");
-            return $@"
-        public OneOf<{resultArgsPrinted}> Map{bindToType}<TResult>(Func<{bindToType}, TResult> mapFunc)
-        {{
-            if (mapFunc == null)
-            {{
-                throw new ArgumentNullException(nameof(mapFunc));
-            }}
-            return _index switch
-            {{
-                {genericArgs.Joined(@"
-                ", (x, k) =>
-                    x == bindToType ?
-                        $"{k} => mapFunc(As{x})," :
-                        $"{k} => As{x},")}
-                _ => throw new InvalidOperationException()
-            }};
-        }}";
-        }))}
-");
-
-    if (i > 1) {
-        sb.AppendLine(
-            RangeJoined(@"
-        ", j => {
-                var genericArgWithSkip = Range(0, i).ExceptSingle(j).Joined(", ", e => $"T{e}");
-                var remainderType = i == 2 ? genericArgWithSkip : $"OneOf<{genericArgWithSkip}>";
-                return $@"
-		public bool TryPickT{j}(out T{j} value, out {remainderType} remainder)
-		{{
-			value = IsT{j} ? AsT{j} : default;
-            remainder = _index switch
-            {{
-                {RangeJoined(@"
-                ", k => 
-                    k == j ?
-                        $"{k} => default," :
-                        $"{k} => AsT{k},")}
-                _ => throw new InvalidOperationException()
-            }};
-			return this.IsT{j};
-		}}";
-            })
-        );
+for (var i = 1; i < 10; i++)
+{
+    using (var contentGenerator =
+        new FileContentGenerator(Combine(sourceRoot, $"OneOf\\OneOfT{i - 1}.generated.cs"), true, i))
+    {
+        contentGenerator.WriteContent();
     }
 
-    sb.AppendLine($@"
-        bool Equals({className}<{genericArg}> other) =>
-            _index == other._index &&
-            _index switch
-            {{
-                {RangeJoined(@"
-                ", j => @$"{j} => Equals(_value{j}, other._value{j}),")}
-                _ => false
-            }};
-
-        public override bool Equals(object obj)
-        {{
-            if (ReferenceEquals(null, obj))
-            {{
-                return false;
-            }}
-
-            {IfStruct(
-            $"return obj is OneOf<{genericArg}> o && Equals(o);",
-            $@"if (ReferenceEquals(this, obj)) {{
-                    return true;
-            }}
-
-            return obj is OneOfBase<{genericArg}> o && Equals(o);"
-            )}
-        }}
-
-        public override string ToString() =>
-            _index switch {{
-                {RangeJoined(@"
-                ", j => $"{j} => FormatValue(_value{j}),")}
-                _ => throw new InvalidOperationException(""Unexpected index, which indicates a problem in the OneOf codegen."")
-            }};
-
-        public override int GetHashCode()
-        {{
-            unchecked
-            {{
-                int hashCode = _index switch
-                {{
-                    {RangeJoined(@"
-                    ", j => $"{j} => _value{j}?.GetHashCode(),")}
-                    _ => 0
-                }} ?? 0;
-                return (hashCode*397) ^ _index;
-            }}
-        }}
-    }}
-}}");
-
-    return sb.ToString();
+    using (var contentGenerator =
+        new FileContentGenerator(Combine(sourceRoot, $"OneOf\\OneOfBaseT{i - 1}.generated.cs"), false, i))
+    {
+        contentGenerator.WriteContent();
+    }
 }
 
-public static class Extensions {
-    public static string Joined<T>(this IEnumerable<T> source, string delimiter, Func<T, string>? selector = null) {
-        if (source == null) { return ""; }
-        if (selector == null) { return string.Join(delimiter, source); }
-        return string.Join(delimiter, source.Select(selector));
+for (var i = 10; i < 33; i++)
+{
+    using (var contentGenerator =
+        new FileContentGenerator(Combine(sourceRoot, $"OneOf.Extended\\OneOfT{i - 1}.generated.cs"), true, i))
+    {
+        contentGenerator.WriteContent();
     }
-    public static string Joined<T>(this IEnumerable<T> source, string delimiter, Func<T, int, string> selector) {
-        if (source == null) { return ""; }
-        return string.Join(delimiter, source.Select(selector));
+
+    using (var contentGenerator =
+        new FileContentGenerator(Combine(sourceRoot, $"OneOf.Extended\\OneOfBaseT{i - 1}.generated.cs"), false, i))
+    {
+        contentGenerator.WriteContent();
     }
-    public static IEnumerable<T> ExceptSingle<T>(this IEnumerable<T> source, T single) => source.Except(Repeat(single, 1));
-    public static void AppendLineTo(this string? s, StringBuilder sb) => sb.AppendLine(s);
-}
\ No newline at end of file
+}
diff --git a/OneOf/OneOfT2.generated.cs b/OneOf/OneOfT2.generated.cs
index 9e4e68c..1d09abb 100644
--- a/OneOf/OneOfT2.generated.cs
+++ b/OneOf/OneOfT2.generated.cs
@@ -49,6 +49,9 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2>(T0 t) => new OneOf<T0, T1, T2>(0, value0: t);
         public static implicit operator OneOf<T0, T1, T2>(T1 t) => new OneOf<T0, T1, T2>(1, value1: t);
         public static implicit operator OneOf<T0, T1, T2>(T2 t) => new OneOf<T0, T1, T2>(2, value2: t);
+        public static implicit operator OneOf<T0, T1, T2>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2>>(x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2)
         {
diff --git a/OneOf/OneOfT3.generated.cs b/OneOf/OneOfT3.generated.cs
index b6556fc..27efefa 100644
--- a/OneOf/OneOfT3.generated.cs
+++ b/OneOf/OneOfT3.generated.cs
@@ -58,6 +58,16 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3>(T1 t) => new OneOf<T0, T1, T2, T3>(1, value1: t);
         public static implicit operator OneOf<T0, T1, T2, T3>(T2 t) => new OneOf<T0, T1, T2, T3>(2, value2: t);
         public static implicit operator OneOf<T0, T1, T2, T3>(T3 t) => new OneOf<T0, T1, T2, T3>(3, value3: t);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3>>(x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3)
         {
diff --git a/OneOf/OneOfT4.generated.cs b/OneOf/OneOfT4.generated.cs
index 38245fb..3f2b72f 100644
--- a/OneOf/OneOfT4.generated.cs
+++ b/OneOf/OneOfT4.generated.cs
@@ -67,6 +67,31 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3, T4>(T2 t) => new OneOf<T0, T1, T2, T3, T4>(2, value2: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4>(T3 t) => new OneOf<T0, T1, T2, T3, T4>(3, value3: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4>(T4 t) => new OneOf<T0, T1, T2, T3, T4>(4, value4: t);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T0, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4>(OneOf<T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4>>(x => x, x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4)
         {
diff --git a/OneOf/OneOfT5.generated.cs b/OneOf/OneOfT5.generated.cs
index 83ac23e..a7e891d 100644
--- a/OneOf/OneOfT5.generated.cs
+++ b/OneOf/OneOfT5.generated.cs
@@ -76,6 +76,62 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(T3 t) => new OneOf<T0, T1, T2, T3, T4, T5>(3, value3: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(T4 t) => new OneOf<T0, T1, T2, T3, T4, T5>(4, value4: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(T5 t) => new OneOf<T0, T1, T2, T3, T4, T5>(5, value5: t);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T0, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5>(OneOf<T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5>>(x => x, x => x, x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5)
         {
diff --git a/OneOf/OneOfT6.generated.cs b/OneOf/OneOfT6.generated.cs
index 9922c8a..55d89f0 100644
--- a/OneOf/OneOfT6.generated.cs
+++ b/OneOf/OneOfT6.generated.cs
@@ -85,6 +85,125 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(T4 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6>(4, value4: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(T5 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6>(5, value5: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(T6 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6>(6, value6: t);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T0, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6>(OneOf<T1, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6>>(x => x, x => x, x => x, x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5, Action<T6> f6)
         {
diff --git a/OneOf/OneOfT7.generated.cs b/OneOf/OneOfT7.generated.cs
index c0b0160..200ed7b 100644
--- a/OneOf/OneOfT7.generated.cs
+++ b/OneOf/OneOfT7.generated.cs
@@ -94,6 +94,252 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(T5 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(5, value5: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(T6 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(6, value6: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(T7 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(7, value7: t);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T1, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T0, T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7>(OneOf<T1, T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5, Action<T6> f6, Action<T7> f7)
         {
diff --git a/OneOf/OneOfT8.generated.cs b/OneOf/OneOfT8.generated.cs
index e040095..377fb45 100644
--- a/OneOf/OneOfT8.generated.cs
+++ b/OneOf/OneOfT8.generated.cs
@@ -103,6 +103,507 @@ namespace OneOf
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T6 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(6, value6: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T7 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(7, value7: t);
         public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T8 t) => new OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(8, value8: t);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T6> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T2, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T6, T7> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T6, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T5, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T4, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T3, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T2, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T1, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T0, T2, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
+        public static implicit operator OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>(OneOf<T1, T2, T3, T4, T5, T6, T7, T8> subset) => subset.Match<OneOf<T0, T1, T2, T3, T4, T5, T6, T7, T8>>(x => x, x => x, x => x, x => x, x => x, x => x, x => x, x => x);
 
         public void Switch(Action<T0> f0, Action<T1> f1, Action<T2> f2, Action<T3> f3, Action<T4> f4, Action<T5> f5, Action<T6> f6, Action<T7> f7, Action<T8> f8)
         {