Imported Upstream version 2.0.0.12082upstream/2.0.0.12082

123 files changed, 24880 insertions, 23250 deletions

diff --git a/BuildToolsVersion.txt b/BuildToolsVersion.txt
index a72a2229ed..c5504693d0 100644
--- a/BuildToolsVersion.txt
+++ b/BuildToolsVersion.txt
@@ -1 +1 @@
-2.0.0-prerelease-01702-02
+2.0.0-prerelease-01721-01
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f55b54c498..45dd65b904 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,7 +31,8 @@ if(CORECLR_SET_RPATH)
     set(MACOSX_RPATH ON)
 endif(CORECLR_SET_RPATH)
 
-OPTION(CMAKE_ENABLE_CODE_COVERAGE "Enable code coverage" OFF)
+OPTION(CLR_CMAKE_ENABLE_CODE_COVERAGE "Enable code coverage" OFF)
+OPTION(CLR_CMAKE_WARNINGS_ARE_ERRORS "Warnings are errors" ON)
 
 # Ensure that python is present
 find_program(PYTHON python)
diff --git a/build-test.cmd b/build-test.cmd
index 6291f502ec..6a320e30d7 100644
--- a/build-test.cmd
+++ b/build-test.cmd
@@ -147,6 +147,14 @@ call "%__ProjectDir%\init-tools.cmd"
 
 REM =========================================================================================
 REM ===
+REM === Resolve runtime dependences
+REM ===
+REM =========================================================================================
+
+call "%__TestDir%\setup-stress-dependencies.cmd" /arch %__BuildArch% /outputdir %__BinDir%
+
+REM =========================================================================================
+REM ===
 REM === Native test build section
 REM ===
 REM =========================================================================================
diff --git a/build.sh b/build.sh
index 55b4ba3200..6590e83d62 100755
--- a/build.sh
+++ b/build.sh
@@ -19,7 +19,7 @@ fi
 
 usage()
 {
-    echo "Usage: $0 [BuildArch] [BuildType] [verbose] [coverage] [cross] [clangx.y] [ninja] [configureonly] [skipconfigure] [skipnative] [skipmscorlib] [skiptests] [stripsymbols] [cmakeargs] [bindir]"
+    echo "Usage: $0 [BuildArch] [BuildType] [verbose] [coverage] [cross] [clangx.y] [ninja] [configureonly] [skipconfigure] [skipnative] [skipmscorlib] [skiptests] [stripsymbols] [ignorewarnings] [cmakeargs] [bindir]"
     echo "BuildArch can be: x64, x86, arm, armel, arm64"
     echo "BuildType can be: debug, checked, release"
     echo "coverage - optional argument to enable code coverage build (currently supported only for Linux and OSX)."
@@ -47,6 +47,7 @@ usage()
 	echo "-Rebuild: passes /t:rebuild to the build projects."
     echo "stripSymbols - Optional argument to strip native symbols during the build."
     echo "skipgenerateversion - disable version generation even if MSBuild is supported."
+    echo "ignorewarnings - do not treat warnings as errors"
     echo "cmakeargs - user-settable additional arguments passed to CMake."
     echo "bindir - output directory (defaults to $__ProjectRoot/bin)"
     echo "buildstandalonegc - builds the GC in a standalone mode. Can't be used with \"cmakeargs\"."
@@ -183,11 +184,17 @@ generate_event_logging_sources()
 
     mkdir -p "$__GeneratedIntermediateEventProvider"
     mkdir -p "$__GeneratedIntermediateEventPipe"
+
+    __PythonWarningFlags="-Wall"
+    if [[ $__IgnoreWarnings == 0 ]]; then
+        __PythonWarningFlags="$__PythonWarningFlags -Werror"
+    fi
+
     
     if [[ $__SkipCoreCLR == 0 || $__ConfigureOnly == 1 ]]; then
         echo "Laying out dynamically generated files consumed by the build system "
         echo "Laying out dynamically generated Event Logging Test files"
-        $PYTHON -B -Wall -Werror "$__ProjectRoot/src/scripts/genXplatEventing.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --exc "$__ProjectRoot/src/vm/ClrEtwAllMeta.lst" --testdir "$__GeneratedIntermediateEventProvider/tests"
+        $PYTHON -B $__PythonWarningFlags "$__ProjectRoot/src/scripts/genXplatEventing.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --exc "$__ProjectRoot/src/vm/ClrEtwAllMeta.lst" --testdir "$__GeneratedIntermediateEventProvider/tests"
 
         if  [[ $? != 0 ]]; then
             exit
@@ -196,7 +203,7 @@ generate_event_logging_sources()
         case $__BuildOS in
             Linux)
                 echo "Laying out dynamically generated EventPipe Implementation"
-                $PYTHON -B -Wall -Werror "$__ProjectRoot/src/scripts/genEventPipe.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --intermediate "$__GeneratedIntermediateEventPipe" --exc "$__ProjectRoot/src/vm/ClrEtwAllMeta.lst"
+                $PYTHON -B $__PythonWarningFlags "$__ProjectRoot/src/scripts/genEventPipe.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --intermediate "$__GeneratedIntermediateEventPipe" --exc "$__ProjectRoot/src/vm/ClrEtwAllMeta.lst"
                 if  [[ $? != 0 ]]; then
                     exit
                 fi
@@ -209,7 +216,7 @@ generate_event_logging_sources()
         case $__BuildOS in
             Linux)
                 echo "Laying out dynamically generated Event Logging Implementation of Lttng"
-                $PYTHON -B -Wall -Werror "$__ProjectRoot/src/scripts/genXplatLttng.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --intermediate "$__GeneratedIntermediateEventProvider"
+                $PYTHON -B $__PythonWarningFlags "$__ProjectRoot/src/scripts/genXplatLttng.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --intermediate "$__GeneratedIntermediateEventProvider"
                 if  [[ $? != 0 ]]; then
                     exit
                 fi
@@ -220,7 +227,7 @@ generate_event_logging_sources()
     fi
 
     echo "Cleaning the temp folder of dynamically generated Event Logging files"
-    $PYTHON -B -Wall -Werror -c "import sys;sys.path.insert(0,\"$__ProjectRoot/src/scripts\"); from Utilities import *;UpdateDirectory(\"$__GeneratedIntermediate/eventprovider\",\"$__GeneratedIntermediateEventProvider\")"
+    $PYTHON -B $__PythonWarningFlags -c "import sys;sys.path.insert(0,\"$__ProjectRoot/src/scripts\"); from Utilities import *;UpdateDirectory(\"$__GeneratedIntermediate/eventprovider\",\"$__GeneratedIntermediateEventProvider\")"
     if  [[ $? != 0 ]]; then
         exit
     fi
@@ -228,7 +235,7 @@ generate_event_logging_sources()
     rm -rf "$__GeneratedIntermediateEventProvider"
 
     echo "Cleaning the temp folder of dynamically generated EventPipe files"
-    $PYTHON -B -Wall -Werror -c "import sys;sys.path.insert(0,\"$__ProjectRoot/src/scripts\"); from Utilities import *;UpdateDirectory(\"$__GeneratedIntermediate/eventpipe\",\"$__GeneratedIntermediateEventPipe\")"
+    $PYTHON -B $__PythonWarningFlags -c "import sys;sys.path.insert(0,\"$__ProjectRoot/src/scripts\"); from Utilities import *;UpdateDirectory(\"$__GeneratedIntermediate/eventpipe\",\"$__GeneratedIntermediateEventPipe\")"
     if  [[ $? != 0 ]]; then
         exit
     fi
@@ -597,6 +604,7 @@ esac
 __BuildType=Debug
 __CodeCoverage=
 __IncludeTests=Include_Tests
+__IgnoreWarnings=0
 
 # Set the various build properties here so that CMake and MSBuild can pick them up
 __ProjectDir="$__ProjectRoot"
@@ -784,6 +792,11 @@ while :; do
             __SkipNuget=1
             ;;
 
+        ignorewarnings)
+            __IgnoreWarnings=1
+            __cmakeargs="$__cmakeargs -DCLR_CMAKE_WARNINGS_ARE_ERRORS=OFF"
+            ;;
+
         cmakeargs)
             if [ -n "$2" ]; then
                 __cmakeargs="$__cmakeargs $2"
diff --git a/buildpipeline/pipelines.json b/buildpipeline/pipelines.json
index c5e98ebcdc..07df8dda2a 100644
--- a/buildpipeline/pipelines.json
+++ b/buildpipeline/pipelines.json
@@ -13,7 +13,7 @@
         {
           "Name": "DotNet-CoreClr-Trusted-Linux",
           "Parameters": {
-            "DockerTag": "rhel7_prereqs_2",
+            "DockerTag": "rhel-7-dd8aa64-20170320090348",
             "Rid": "linux"
           },
           "ReportingParameters": {
diff --git a/compileoptions.cmake b/compileoptions.cmake
index 75d51fd5bb..9f9f28eaf5 100644
--- a/compileoptions.cmake
+++ b/compileoptions.cmake
@@ -23,8 +23,10 @@ if (CLR_CMAKE_PLATFORM_UNIX)
   # after hitting just about 20 errors.
   add_compile_options(-ferror-limit=4096)
 
-  # All warnings that are not explicitly disabled are reported as errors
-  add_compile_options(-Werror)
+  if (CLR_CMAKE_WARNINGS_ARE_ERRORS)
+    # All warnings that are not explicitly disabled are reported as errors
+    add_compile_options(-Werror)
+  endif(CLR_CMAKE_WARNINGS_ARE_ERRORS)
 
   # Disabled warnings
   add_compile_options(-Wno-unused-private-field)
@@ -121,7 +123,7 @@ if (WIN32)
   
 endif (WIN32)
 
-if(CMAKE_ENABLE_CODE_COVERAGE)
+if(CLR_CMAKE_ENABLE_CODE_COVERAGE)
 
   if(CLR_CMAKE_PLATFORM_UNIX)
     string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
@@ -138,4 +140,4 @@ if(CMAKE_ENABLE_CODE_COVERAGE)
     message(FATAL_ERROR "Code coverage builds not supported on current platform")
   endif(CLR_CMAKE_PLATFORM_UNIX)
 
-endif(CMAKE_ENABLE_CODE_COVERAGE)
+endif(CLR_CMAKE_ENABLE_CODE_COVERAGE)
diff --git a/dependencies.props b/dependencies.props
index 8aada2c0a2..435b685da9 100644
--- a/dependencies.props
+++ b/dependencies.props
@@ -5,26 +5,26 @@
     <PackageVersion Condition="'$(PackageVersion)' == ''">2.0.0</PackageVersion>
     
     <!-- Set the boolean below to true to generate packages with stabilized versions -->
-    <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">false</StabilizePackageVersion>
+    <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">true</StabilizePackageVersion>
     <StableVersion Condition="'$(StabilizePackageVersion)' == 'true' and '$(StableVersion)' == ''">$(PackageVersion)</StableVersion>
 
-    <PreReleaseLabel>preview2</PreReleaseLabel>
+    <PreReleaseLabel>preview3</PreReleaseLabel>
   </PropertyGroup>
   
   <!-- Source of truth for dependency tooling: the commit hash of the dotnet/versions master branch as of the last auto-upgrade. -->
   <PropertyGroup>
-    <CoreFxCurrentRef>d4040dc6f74933eec9827d44e288c9cd15996a15</CoreFxCurrentRef>
-    <CoreClrCurrentRef>d4040dc6f74933eec9827d44e288c9cd15996a15</CoreClrCurrentRef>
+    <CoreFxCurrentRef>cfaaf5de4349877a3e2c4f7c9df5784b8bc209a5</CoreFxCurrentRef>
+    <CoreClrCurrentRef>cfaaf5de4349877a3e2c4f7c9df5784b8bc209a5</CoreClrCurrentRef>
   </PropertyGroup>
 
   <!-- Auto-upgraded properties for each build info dependency. -->
   <PropertyGroup>
-    <CoreFxExpectedPrerelease>preview2-25331-01</CoreFxExpectedPrerelease>
+    <CoreFxExpectedPrerelease>preview3-25519-01</CoreFxExpectedPrerelease>
   </PropertyGroup>
 
   <!-- Full package version strings that are used in other parts of the build. -->
   <PropertyGroup>
-    <CoreClrPackageVersion>2.0.0-preview2-25330-02</CoreClrPackageVersion>
+    <CoreClrPackageVersion>2.0.0-preview3-25519-01</CoreClrPackageVersion>
     <XunitPackageVersion>2.2.0-beta2-build3300</XunitPackageVersion>
     <XUnitConsoleNetCoreVersion>1.0.2-prerelease-00177</XUnitConsoleNetCoreVersion>
     <XUnitPerformanceApiVersion>1.0.0-beta-build0007</XUnitPerformanceApiVersion>
diff --git a/dir.props b/dir.props
index 9668768507..8b699ab053 100644
--- a/dir.props
+++ b/dir.props
@@ -23,7 +23,7 @@
 
   <!-- Profile-based optimization data package versions -->
   <PropertyGroup>
-    <PgoDataPackageVersion>2.0.0-release-20170531-3000</PgoDataPackageVersion>
+    <PgoDataPackageVersion>2.0.0-release-20170711-0120</PgoDataPackageVersion>
     <!--<IbcDataPackageVersion></IbcDataPackageVersion>-->
   </PropertyGroup>
 
diff --git a/perf.groovy b/perf.groovy
index 9be47c0b3c..d2a4c327ee 100644
--- a/perf.groovy
+++ b/perf.groovy
@@ -88,9 +88,9 @@ def static getOSGroup(def os) {
                         batchFile("\"%WORKSPACE%\\nuget.exe\" install Microsoft.BenchView.JSONFormat -Source http://benchviewtestfeed.azurewebsites.net/nuget -OutputDirectory \"%WORKSPACE%\" -Prerelease -ExcludeVersion")
                         //Do this here to remove the origin but at the front of the branch name as this is a problem for BenchView
                         //we have to do it all as one statement because cmd is called each time and we lose the set environment variable
-                        batchFile("if [%GIT_BRANCH:~0,7%] == [origin/] (set GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH:origin/=%) else (set GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH%)\n" +
-                        "set BENCHVIEWNAME=${benchViewName}\n" +
-                        "set BENCHVIEWNAME=%BENCHVIEWNAME:\"=%\n" +
+                        batchFile("if \"%GIT_BRANCH:~0,7%\" == \"origin/\" (set \"GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH:origin/=%\") else (set \"GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH%\")\n" +
+                        "set \"BENCHVIEWNAME=${benchViewName}\"\n" +
+                        "set \"BENCHVIEWNAME=%BENCHVIEWNAME:\"=%\"\n" +
                         "py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\submission-metadata.py\" --name \"%BENCHVIEWNAME%\" --user \"dotnet-bot@microsoft.com\"\n" +
                         "py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\build.py\" git --branch %GIT_BRANCH_WITHOUT_ORIGIN% --type ${runType}")
                         batchFile("py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\machinedata.py\"")
@@ -198,9 +198,9 @@ def static getOSGroup(def os) {
                     batchFile("C:\\Tools\\nuget.exe install Microsoft.BenchView.ThroughputBenchmarks.${architecture}.${os} -Source https://dotnet.myget.org/F/dotnet-core -OutputDirectory \"%WORKSPACE%\" -Prerelease -ExcludeVersion")
                     //Do this here to remove the origin but at the front of the branch name as this is a problem for BenchView
                     //we have to do it all as one statement because cmd is called each time and we lose the set environment variable
-                    batchFile("if [%GIT_BRANCH:~0,7%] == [origin/] (set GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH:origin/=%) else (set GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH%)\n" +
-                    "set BENCHVIEWNAME=${benchViewName}\n" +
-                    "set BENCHVIEWNAME=%BENCHVIEWNAME:\"=%\n" +
+                    batchFile("if \"%GIT_BRANCH:~0,7%\" == \"origin/\" (set \"GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH:origin/=%\") else (set \"GIT_BRANCH_WITHOUT_ORIGIN=%GIT_BRANCH%\")\n" +
+                    "set \"BENCHVIEWNAME=${benchViewName}\"\n" +
+                    "set \"BENCHVIEWNAME=%BENCHVIEWNAME:\"=%\"\n" +
                     "py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\submission-metadata.py\" --name \"${benchViewName}\" --user \"dotnet-bot@microsoft.com\"\n" +
                     "py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\build.py\" git --branch %GIT_BRANCH_WITHOUT_ORIGIN% --type ${runType}")
                     batchFile("py \"%WORKSPACE%\\Microsoft.BenchView.JSONFormat\\tools\\machinedata.py\"")
@@ -234,10 +234,32 @@ def static getOSGroup(def os) {
     }
 }
 
+def static getFullPerfJobName(def project, def os, def isPR) {
+    return Utilities.getFullJobName(project, "perf_${os}", isPR)
+}
+
 // Create the Linux/OSX/CentOS coreclr test leg for debug and release and each scenario
 [true, false].each { isPR ->
-    ['Ubuntu14.04'].each { os ->
-        def newJob = job(Utilities.getFullJobName(project, "perf_${os}", isPR)) {
+    def fullBuildJobName = Utilities.getFullJobName(project, 'perf_linux_build', isPR)
+    def architecture = 'x64'
+    def configuration = 'Release'
+
+    // Build has to happen on RHEL7.2 (that's where we produce the bits we ship)
+    ['RHEL7.2'].each { os ->
+        def newBuildJob = job(fullBuildJobName) {
+            steps {
+                shell("./build.sh verbose ${architecture} ${configuration}")
+            }
+        }
+        Utilities.setMachineAffinity(newBuildJob, os, 'latest-or-auto')
+        Utilities.standardJobSetup(newBuildJob, project, isPR, "*/${branch}")
+        Utilities.addArchival(newBuildJob, "bin/Product/**,bin/obj/*/tests/**/*.dylib,bin/obj/*/tests/**/*.so", "bin/Product/**/.nuget/**")
+    }
+
+    // Actual perf testing on the following OSes
+    def perfOSList = ['Ubuntu14.04']
+    perfOSList.each { os ->
+        def newJob = job(getFullPerfJobName(project, os, isPR)) {
 
             label('linux_clr_perf')
             wrappers {
@@ -254,22 +276,26 @@ def static getOSGroup(def os) {
                 }
             }
 
-            // Cap the maximum number of iterations to 21.
             parameters {
+                // Cap the maximum number of iterations to 21.
                 stringParam('XUNIT_PERFORMANCE_MAX_ITERATION', '21', 'Sets the number of iterations to twenty one.  We are doing this to limit the amount of data that we upload as 20 iterations is enought to get a good sample')
                 stringParam('XUNIT_PERFORMANCE_MAX_ITERATION_INNER_SPECIFIED', '21', 'Sets the number of iterations to twenty one.  We are doing this to limit the amount of data that we upload as 20 iterations is enought to get a good sample')
+                stringParam('PRODUCT_BUILD', '', 'Build number from which to copy down the CoreCLR Product binaries built for Linux')
             }
 
             def osGroup = getOSGroup(os)
-            def architecture = 'x64'
-            def configuration = 'Release'
             def runType = isPR ? 'private' : 'rolling'
             def benchViewName = isPR ? 'coreclr private \$BenchviewCommitName' : 'coreclr rolling \$GIT_BRANCH_WITHOUT_ORIGIN \$GIT_COMMIT'
 
             steps {
                 shell("./tests/scripts/perf-prep.sh")
                 shell("./init-tools.sh")
-                shell("./build.sh ${architecture} ${configuration}")
+                copyArtifacts(fullBuildJobName) {
+                    includePatterns("bin/**")
+                    buildSelector {
+                        buildNumber('\${PRODUCT_BUILD}')
+                    }
+                }
                 shell("GIT_BRANCH_WITHOUT_ORIGIN=\$(echo \$GIT_BRANCH | sed \"s/[^/]*\\/\\(.*\\)/\\1 /\")\n" +
                 "python3.5 \"\${WORKSPACE}/tests/scripts/Microsoft.BenchView.JSONFormat/tools/submission-metadata.py\" --name \" ${benchViewName} \" --user \"dotnet-bot@microsoft.com\"\n" +
                 "python3.5 \"\${WORKSPACE}/tests/scripts/Microsoft.BenchView.JSONFormat/tools/build.py\" git --branch \$GIT_BRANCH_WITHOUT_ORIGIN --type ${runType}")
@@ -306,26 +332,73 @@ def static getOSGroup(def os) {
                 numToKeep(1000)
             }
         }
+    } // os
+
+    def flowJobPerfRunList = perfOSList.collect { os ->
+        "{ build(params + [PRODUCT_BUILD: b.build.number], '${getFullPerfJobName(project, os, isPR)}') }"
+    }
+    def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, "perf_linux_flow", isPR, '')) {
         if (isPR) {
-            TriggerBuilder builder = TriggerBuilder.triggerOnPullRequest()
-            builder.setGithubContext("${os} Perf Tests")
-            builder.triggerOnlyOnComment()
-            builder.setCustomTriggerPhrase("(?i).*test\\W+${os}\\W+perf.*")
-            builder.triggerForBranch(branch)
-            builder.emitTrigger(newJob)
-        }
-        else {
-            // Set a push trigger
-            TriggerBuilder builder = TriggerBuilder.triggerOnCommit()
-            builder.emitTrigger(newJob)
+            parameters {
+                stringParam('BenchviewCommitName', '\${ghprbPullTitle}', 'The name that you will be used to build the full title of a run in Benchview.  The final name will be of the form <branch> private BenchviewCommitName')
+            }
         }
-    } // os
+        buildFlow("""
+// First, build the bits on RHEL7.2
+b = build(params, '${fullBuildJobName}')
+
+// Then, run the perf tests
+parallel(
+    ${flowJobPerfRunList.join(",\n    ")}
+)
+""")
+    }
+
+    Utilities.setMachineAffinity(newFlowJob, 'Windows_NT', 'latest-or-auto')
+    Utilities.standardJobSetup(newFlowJob, project, isPR, "*/${branch}")
+
+    if (isPR) {
+        TriggerBuilder builder = TriggerBuilder.triggerOnPullRequest()
+        builder.setGithubContext("Linux Perf Test Flow")
+        builder.triggerOnlyOnComment()
+        builder.setCustomTriggerPhrase("(?i).*test\\W+linux\\W+perf\\W+flow.*")
+        builder.triggerForBranch(branch)
+        builder.emitTrigger(newFlowJob)
+    }
+    else {
+        // Set a push trigger
+        TriggerBuilder builder = TriggerBuilder.triggerOnCommit()
+        builder.emitTrigger(newFlowJob)
+    }
+
 } // isPR
 
+def static getFullThroughputJobName(def project, def os, def isPR) {
+    return Utilities.getFullJobName(project, "perf_throughput_${os}", isPR)
+}
+
 // Create the Linux/OSX/CentOS coreclr test leg for debug and release and each scenario
 [true, false].each { isPR ->
-    ['Ubuntu14.04'].each { os ->
-        def newJob = job(Utilities.getFullJobName(project, "perf_throughput_${os}", isPR)) {
+    def fullBuildJobName = Utilities.getFullJobName(project, 'perf_throughput_linux_build', isPR)
+    def architecture = 'x64'
+    def configuration = 'Release'
+
+    // Build has to happen on RHEL7.2 (that's where we produce the bits we ship)
+    ['RHEL7.2'].each { os ->
+        def newBuildJob = job(fullBuildJobName) {
+            steps {
+                shell("./build.sh verbose ${architecture} ${configuration}")
+            }
+        }
+        Utilities.setMachineAffinity(newBuildJob, os, 'latest-or-auto')
+        Utilities.standardJobSetup(newBuildJob, project, isPR, "*/${branch}")
+        Utilities.addArchival(newBuildJob, "bin/Product/**")
+    }
+
+    // Actual perf testing on the following OSes
+    def throughputOSList = ['Ubuntu14.04']
+    throughputOSList.each { os ->
+        def newJob = job(getFullThroughputJobName(project, os, isPR)) {
 
             label('linux_clr_perf')
                 wrappers {
@@ -341,16 +414,24 @@ def static getOSGroup(def os) {
                     stringParam('BenchviewCommitName', '\${ghprbPullTitle}', 'The name that you will be used to build the full title of a run in Benchview.  The final name will be of the form <branch> private BenchviewCommitName')
                 }
             }
+
+            parameters {
+                stringParam('PRODUCT_BUILD', '', 'Build number from which to copy down the CoreCLR Product binaries built for Linux')
+            }
+
             def osGroup = getOSGroup(os)
-            def architecture = 'x64'
-            def configuration = 'Release'
             def runType = isPR ? 'private' : 'rolling'
             def benchViewName = isPR ? 'coreclr private \$BenchviewCommitName' : 'coreclr rolling \$GIT_BRANCH_WITHOUT_ORIGIN \$GIT_COMMIT'
 
             steps {
                 shell("bash ./tests/scripts/perf-prep.sh --throughput")
                 shell("./init-tools.sh")
-                shell("./build.sh ${architecture} ${configuration}")
+                copyArtifacts(fullBuildJobName) {
+                    includePatterns("bin/Product/**")
+                    buildSelector {
+                        buildNumber('\${PRODUCT_BUILD}')
+                    }
+                }
                 shell("GIT_BRANCH_WITHOUT_ORIGIN=\$(echo \$GIT_BRANCH | sed \"s/[^/]*\\/\\(.*\\)/\\1 /\")\n" +
                 "python3.5 \"\${WORKSPACE}/tests/scripts/Microsoft.BenchView.JSONFormat/tools/submission-metadata.py\" --name \" ${benchViewName} \" --user \"dotnet-bot@microsoft.com\"\n" +
                 "python3.5 \"\${WORKSPACE}/tests/scripts/Microsoft.BenchView.JSONFormat/tools/build.py\" git --branch \$GIT_BRANCH_WITHOUT_ORIGIN --type ${runType}")
@@ -359,7 +440,7 @@ def static getOSGroup(def os) {
                 -os \"${os}\" \\
                 -configuration \"${configuration}\" \\
                 -clr_root \"\${WORKSPACE}\" \\
-                -assembly_root \"\${WORKSPACE}/_/fx/bin/runtime/netcoreapp-${osGroup}-${configuration}-${architecture}\" \\
+                -assembly_root \"\${WORKSPACE}/Microsoft.Benchview.ThroughputBenchmarks.${architecture}.Windows_NT/lib\" \\
                 -run_type \"${runType}\" \\
                 -benchview_path \"\${WORKSPACE}/tests/scripts/Microsoft.BenchView.JSONFormat/tools\"""")
             }
@@ -383,18 +464,43 @@ def static getOSGroup(def os) {
                 numToKeep(1000)
             }
         }
+    } // os
+
+    def flowJobTPRunList = throughputOSList.collect { os ->
+        "{ build(params + [PRODUCT_BUILD: b.build.number], '${getFullThroughputJobName(project, os, isPR)}') }"
+    }
+    def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, "perf_throughput_linux_flow", isPR, '')) {
         if (isPR) {
-            TriggerBuilder builder = TriggerBuilder.triggerOnPullRequest()
-            builder.setGithubContext("${os} Throughput Perf Tests")
-            builder.triggerOnlyOnComment()
-            builder.setCustomTriggerPhrase("(?i).*test\\W+${os}\\W+throughput.*")
-            builder.triggerForBranch(branch)
-            builder.emitTrigger(newJob)
-        }
-        else {
-            // Set a push trigger
-            TriggerBuilder builder = TriggerBuilder.triggerOnCommit()
-            builder.emitTrigger(newJob)
+            parameters {
+                stringParam('BenchviewCommitName', '\${ghprbPullTitle}', 'The name that you will be used to build the full title of a run in Benchview.  The final name will be of the form <branch> private BenchviewCommitName')
+            }
         }
-    } // os
+        buildFlow("""
+// First, build the bits on RHEL7.2
+b = build(params, '${fullBuildJobName}')
+
+// Then, run the perf tests
+parallel(
+    ${flowJobTPRunList.join(",\n    ")}
+)
+""")
+    }
+
+    Utilities.setMachineAffinity(newFlowJob, 'Windows_NT', 'latest-or-auto')
+    Utilities.standardJobSetup(newFlowJob, project, isPR, "*/${branch}")
+
+    if (isPR) {
+        TriggerBuilder builder = TriggerBuilder.triggerOnPullRequest()
+        builder.setGithubContext("Linux Throughput Perf Test Flow")
+        builder.triggerOnlyOnComment()
+        builder.setCustomTriggerPhrase("(?i).*test\\W+linux\\W+throughput\\W+flow.*")
+        builder.triggerForBranch(branch)
+        builder.emitTrigger(newFlowJob)
+    }
+    else {
+        // Set a push trigger
+        TriggerBuilder builder = TriggerBuilder.triggerOnCommit()
+        builder.emitTrigger(newFlowJob)
+    }
+
 } // isPR
diff --git a/pgosupport.cmake b/pgosupport.cmake
index 90bcbc3876..e92923fcb0 100644
--- a/pgosupport.cmake
+++ b/pgosupport.cmake
@@ -11,17 +11,18 @@ function(add_pgo TargetName)
     if(WIN32)
         set(ProfileFileName "${TargetName}.pgd")
     else(WIN32)
-        # Clang/LLVM uses one profdata file for the entire repo
-        set(ProfileFileName "coreclr.profdata")
+        set(ProfileFileName "${TargetName}.profdata")
     endif(WIN32)
 
     set(CLR_CMAKE_OPTDATA_PACKAGEWITHRID "optimization.${CLR_CMAKE_TARGET_OS}-${CLR_CMAKE_TARGET_ARCH}.PGO.CoreCLR")
+
+    # On case-sensitive file systems, NuGet packages are restored to lowercase paths
+    string(TOLOWER "${CLR_CMAKE_OPTDATA_PACKAGEWITHRID}/${CLR_CMAKE_OPTDATA_VERSION}" OptDataVersionedSubPath)
+
     file(TO_NATIVE_PATH
-        "${CLR_CMAKE_PACKAGES_DIR}/${CLR_CMAKE_OPTDATA_PACKAGEWITHRID}/${CLR_CMAKE_OPTDATA_VERSION}/data/${ProfileFileName}"
+        "${CLR_CMAKE_PACKAGES_DIR}/${OptDataVersionedSubPath}/data/${ProfileFileName}"
         ProfilePath
     )
-    # NuGet packages are restored to lowercase paths
-    string(TOLOWER "${ProfilePath}" ProfilePath)
 
     if(CLR_CMAKE_PGO_INSTRUMENT)
         if(WIN32)
@@ -41,10 +42,16 @@ function(add_pgo TargetName)
                 set_property(TARGET ${TargetName} APPEND_STRING PROPERTY LINK_FLAGS_RELWITHDEBINFO " /LTCG /USEPROFILE:PGD=${ProfilePath}")
             else(WIN32)
                 if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELWITHDEBINFO)
-                    if(HAVE_LTO)
-                        target_compile_options(${TargetName} PRIVATE -flto -fprofile-instr-use=${ProfilePath} -Wno-profile-instr-out-of-date)
-                        set_property(TARGET ${TargetName} APPEND_STRING PROPERTY LINK_FLAGS " -flto -fuse-ld=gold -fprofile-instr-use=${ProfilePath}")
-                    endif(HAVE_LTO)
+                    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
+                        if(HAVE_LTO)
+                            target_compile_options(${TargetName} PRIVATE -flto -fprofile-instr-use=${ProfilePath} -Wno-profile-instr-out-of-date)
+                            set_property(TARGET ${TargetName} APPEND_STRING PROPERTY LINK_FLAGS " -flto -fuse-ld=gold -fprofile-instr-use=${ProfilePath}")
+                        else(HAVE_LTO)
+                            message(WARNING "LTO is not supported, skipping profile guided optimizations")
+                        endif(HAVE_LTO)
+                    else(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
+                        message(WARNING "PGO is not supported; Clang 3.6 or later is required for profile guided optimizations")
+                    endif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
                 endif(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELWITHDEBINFO)
             endif(WIN32)
         endif(EXISTS ${ProfilePath})
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b761b6a82d..d8a3abf68d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -53,9 +53,15 @@ else()
     )
 endif(WIN32)
 
+if(CLR_CMAKE_WARNINGS_ARE_ERRORS)
+    set(PYTHON_WARNING_FLAGS -Wall -Werror)
+else()
+    set(PYTHON_WARNING_FLAGS -Wall)
+endif(CLR_CMAKE_WARNINGS_ARE_ERRORS)
+
 add_custom_command(
   COMMENT "Generating Eventing Files"
-  COMMAND ${PYTHON} -B -Wall -Werror ${GenEventFilesScript} ${GenEventArgs} --man "${VM_DIR}/ClrEtwAll.man" --exc "${VM_DIR}/ClrEtwAllMeta.lst" --dummy "${GENERATED_INCLUDE_DIR}/etmdummy.h"
+  COMMAND ${PYTHON} -B ${PYTHON_WARNING_FLAGS} ${GenEventFilesScript} ${GenEventArgs} --man "${VM_DIR}/ClrEtwAll.man" --exc "${VM_DIR}/ClrEtwAllMeta.lst" --dummy "${GENERATED_INCLUDE_DIR}/etmdummy.h"
   OUTPUT ${ScriptGeneratedEventFiles}
   DEPENDS ${GenEventFilesScript} "${VM_DIR}/ClrEtwAll.man" "${VM_DIR}/ClrEtwAllMeta.lst" "${CLR_DIR}/src/scripts/genXplatEventing.py"
 )
diff --git a/src/debug/createdump/crashinfo.cpp b/src/debug/createdump/crashinfo.cpp
index b825f4d301..edc31616de 100644
--- a/src/debug/createdump/crashinfo.cpp
+++ b/src/debug/createdump/crashinfo.cpp
@@ -89,6 +89,10 @@ CrashInfo::EnumMemoryRegion(
     return S_OK;
 }
 
+//
+// Suspends all the threads and creating a list of them. Should be the first before 
+// gather any info about the process.
+//
 bool 
 CrashInfo::EnumerateAndSuspendThreads()
 {
@@ -134,6 +138,9 @@ CrashInfo::EnumerateAndSuspendThreads()
     return true;
 }
 
+//
+// Gather all the necessary crash dump info.
+//
 bool
 CrashInfo::GatherCrashInfo(const char* programPath, MINIDUMP_TYPE minidumpType)
 {
@@ -168,42 +175,33 @@ CrashInfo::GatherCrashInfo(const char* programPath, MINIDUMP_TYPE minidumpType)
     // If full memory dump, include everything regardless of permissions
     if (minidumpType & MiniDumpWithFullMemory)
     {
-       for (const MemoryRegion& region : m_moduleMappings)
-       {
-            if (ValidRegion(region))
-            {
-                InsertMemoryRegion(region);
-            }
+        for (const MemoryRegion& region : m_moduleMappings)
+        {
+            InsertMemoryBackedRegion(region);
         }
         for (const MemoryRegion& region : m_otherMappings)
         {
-            if (ValidRegion(region))
-            {
-                InsertMemoryRegion(region);
-            }
+            InsertMemoryBackedRegion(region);
         }
     }
-    else
+    // Add all the heap (read/write) memory regions (m_otherMappings contains the heaps)
+    else if (minidumpType & MiniDumpWithPrivateReadWriteMemory)
     {
-        // Add all the heap (read/write) memory regions but not the modules' r/w data segments
-        if (minidumpType & MiniDumpWithPrivateReadWriteMemory)
+        for (const MemoryRegion& region : m_otherMappings)
         {
-            for (const MemoryRegion& region : m_otherMappings)
+            if (region.Permissions() == (PF_R | PF_W))
             {
-                if (region.Permissions() == (PF_R | PF_W))
-                {
-                    if (ValidRegion(region))
-                    {
-                        InsertMemoryRegion(region);
-                    }
-                }
+                InsertMemoryBackedRegion(region);
             }
         }
-        // Gather all the useful memory regions from the DAC
-        if (!EnumerateMemoryRegionsWithDAC(programPath, minidumpType))
-        {
-            return false;
-        }
+    }
+    // Gather all the useful memory regions from the DAC
+    if (!EnumerateMemoryRegionsWithDAC(programPath, minidumpType))
+    {
+        return false;
+    }
+    if ((minidumpType & MiniDumpWithFullMemory) == 0)
+    {
         // Add the thread's stack and some code memory to core
         for (ThreadInfo* thread : m_threads)
         {
@@ -217,6 +215,19 @@ CrashInfo::GatherCrashInfo(const char* programPath, MINIDUMP_TYPE minidumpType)
             thread->GetThreadCode(&start, &size);
             InsertMemoryRegion(start, size);
         }
+        // All the regions added so far has been backed by memory. Now add the rest of 
+        // mappings so the debuggers like lldb see that an address is code (PF_X) even
+        // if it isn't actually in the core dump.
+        for (const MemoryRegion& region : m_moduleMappings)
+        {
+            assert(!region.IsBackedByMemory());
+            InsertMemoryRegion(region);
+        }
+        for (const MemoryRegion& region : m_otherMappings)
+        {
+            assert(!region.IsBackedByMemory());
+            InsertMemoryRegion(region);
+        }
     }
     // Join all adjacent memory regions
     CombineMemoryRegions();
@@ -235,6 +246,9 @@ CrashInfo::ResumeThreads()
     }
 }
 
+//
+// Get the auxv entries to use and add to the core dump
+//
 bool 
 CrashInfo::GetAuxvEntries()
 {
@@ -269,6 +283,9 @@ CrashInfo::GetAuxvEntries()
     return result;
 }
 
+//
+// Get the module mappings for the core dump NT_FILE notes
+//
 bool
 CrashInfo::EnumerateModuleMappings()
 {
@@ -320,30 +337,38 @@ CrashInfo::EnumerateModuleMappings()
         int c = sscanf(line, "%lx-%lx %m[-rwxsp] %lx %*[:0-9a-f] %*d %ms\n", &start, &end, &permissions, &offset, &moduleName);
         if (c == 4 || c == 5)
         {
-            if (linuxGateAddress != nullptr && reinterpret_cast<void*>(start) == linuxGateAddress)
-            {
-                InsertMemoryRegion(start, end - start);
-                free(moduleName);
+            // r = read
+            // w = write
+            // x = execute
+            // s = shared
+            // p = private (copy on write)
+            uint32_t regionFlags = 0;
+            if (strchr(permissions, 'r')) {
+                regionFlags |= PF_R;
             }
-            else {
-                uint32_t permissionFlags = 0;
-                if (strchr(permissions, 'r')) {
-                    permissionFlags |= PF_R;
-                }
-                if (strchr(permissions, 'w')) {
-                    permissionFlags |= PF_W;
-                }
-                if (strchr(permissions, 'x')) {
-                    permissionFlags |= PF_X;
-                }
-                MemoryRegion memoryRegion(permissionFlags, start, end, offset, moduleName);
+            if (strchr(permissions, 'w')) {
+                regionFlags |= PF_W;
+            }
+            if (strchr(permissions, 'x')) {
+                regionFlags |= PF_X;
+            }
+            if (strchr(permissions, 's')) {
+                regionFlags |= MEMORY_REGION_FLAG_SHARED;
+            }
+            if (strchr(permissions, 'p')) {
+                regionFlags |= MEMORY_REGION_FLAG_PRIVATE;
+            }
+            MemoryRegion memoryRegion(regionFlags, start, end, offset, moduleName);
 
-                if (moduleName != nullptr && *moduleName == '/') {
-                    m_moduleMappings.insert(memoryRegion);
-                }
-                else {
-                    m_otherMappings.insert(memoryRegion);
-                }
+            if (moduleName != nullptr && *moduleName == '/') {
+                m_moduleMappings.insert(memoryRegion);
+            }
+            else {
+                m_otherMappings.insert(memoryRegion);
+            }
+            if (linuxGateAddress != nullptr && reinterpret_cast<void*>(start) == linuxGateAddress)
+            {
+                InsertMemoryBackedRegion(memoryRegion);
             }
             free(permissions);
         }
@@ -354,12 +379,12 @@ CrashInfo::EnumerateModuleMappings()
         TRACE("Module mappings:\n");
         for (const MemoryRegion& region : m_moduleMappings)
         {
-            region.Print();
+            region.Trace();
         }
         TRACE("Other mappings:\n");
         for (const MemoryRegion& region : m_otherMappings)
         {
-            region.Print();
+            region.Trace();
         }
     }
 
@@ -369,12 +394,16 @@ CrashInfo::EnumerateModuleMappings()
     return true;
 }
 
+//
+// All the shared (native) module info to the core dump
+//
 bool
 CrashInfo::GetDSOInfo()
 {
     Phdr* phdrAddr = reinterpret_cast<Phdr*>(m_auxvValues[AT_PHDR]);
     int phnum = m_auxvValues[AT_PHNUM];
     assert(m_auxvValues[AT_PHENT] == sizeof(Phdr));
+    assert(phnum != PN_XNUM);
 
     if (phnum <= 0 || phdrAddr == nullptr) {
         return false;
@@ -387,6 +416,7 @@ CrashInfo::GetDSOInfo()
     {
         Phdr ph;
         if (!ReadMemory(phdrAddr, &ph, sizeof(ph))) {
+            fprintf(stderr, "ReadMemory(%p, %lx) phdr FAILED\n", phdrAddr, sizeof(ph));
             return false;
         }
         TRACE("DSO: phdr %p type %d (%x) vaddr %016lx memsz %016lx offset %016lx\n", 
@@ -396,7 +426,7 @@ CrashInfo::GetDSOInfo()
         {
             dynamicAddr = reinterpret_cast<ElfW(Dyn)*>(ph.p_vaddr);
         }
-        else if (ph.p_type == PT_GNU_EH_FRAME)
+        else if (ph.p_type == PT_NOTE || ph.p_type == PT_GNU_EH_FRAME)
         {
             if (ph.p_vaddr != 0 && ph.p_memsz != 0)
             {
@@ -414,6 +444,7 @@ CrashInfo::GetDSOInfo()
     for (;;) {
         ElfW(Dyn) dyn;
         if (!ReadMemory(dynamicAddr, &dyn, sizeof(dyn))) {
+            fprintf(stderr, "ReadMemory(%p, %lx) dyn FAILED\n", dynamicAddr, sizeof(dyn));
             return false;
         }
         TRACE("DSO: dyn %p tag %ld (%lx) d_ptr %016lx\n", dynamicAddr, dyn.d_tag, dyn.d_tag, dyn.d_un.d_ptr);
@@ -430,6 +461,7 @@ CrashInfo::GetDSOInfo()
     TRACE("DSO: rdebugAddr %p\n", rdebugAddr);
     struct r_debug debugEntry;
     if (!ReadMemory(rdebugAddr, &debugEntry, sizeof(debugEntry))) {
+        fprintf(stderr, "ReadMemory(%p, %lx) r_debug FAILED\n", rdebugAddr, sizeof(debugEntry));
         return false;
     }
 
@@ -438,8 +470,10 @@ CrashInfo::GetDSOInfo()
     for (struct link_map* linkMapAddr = debugEntry.r_map; linkMapAddr != nullptr;) {
         struct link_map map;
         if (!ReadMemory(linkMapAddr, &map, sizeof(map))) {
+            fprintf(stderr, "ReadMemory(%p, %lx) link_map FAILED\n", linkMapAddr, sizeof(map));
             return false;
         }
+        // Read the module's name and make sure the memory is added to the core dump
         int i = 0;
         if (map.l_name != nullptr) {
             for (; i < PATH_MAX; i++)
@@ -454,18 +488,134 @@ CrashInfo::GetDSOInfo()
             }
         }
         moduleName[i] = '\0';
-        TRACE("DSO: link_map entry %p l_ld %p l_addr %lx %s\n", linkMapAddr, map.l_ld, map.l_addr, (char*)moduleName);
+        TRACE("\nDSO: link_map entry %p l_ld %p l_addr (Ehdr) %lx %s\n", linkMapAddr, map.l_ld, map.l_addr, (char*)moduleName);
+
+        // Read the ELF header and info adding it to the core dump
+        if (!GetELFInfo(map.l_addr)) {
+            return false;
+        }
         linkMapAddr = map.l_next;
     }
 
     return true;
 }
 
+inline bool
+NameCompare(const char* name, const char* sectionName)
+{
+    return strncmp(name, sectionName, strlen(sectionName) + 1) == 0;
+}
+
+//
+// Add all the necessary ELF headers to the core dump
+//
+bool
+CrashInfo::GetELFInfo(uint64_t baseAddress)
+{
+    if (baseAddress == 0) {
+        return true;
+    }
+    Ehdr ehdr;
+    if (!ReadMemory((void*)baseAddress, &ehdr, sizeof(ehdr))) {
+        fprintf(stderr, "ReadMemory(%p, %lx) ehdr FAILED\n", (void*)baseAddress, sizeof(ehdr));
+        return false;
+    }
+    int phnum = ehdr.e_phnum;
+    int shnum = ehdr.e_shnum;
+    assert(phnum != PN_XNUM);
+    assert(shnum != SHN_XINDEX);
+    assert(ehdr.e_shstrndx != SHN_XINDEX);
+    assert(ehdr.e_phentsize == sizeof(Phdr));
+    assert(ehdr.e_shentsize == sizeof(Shdr));
+    assert(ehdr.e_ident[EI_CLASS] == ELFCLASS64);
+    assert(ehdr.e_ident[EI_DATA] == ELFDATA2LSB);
+
+    TRACE("ELF: type %d mach 0x%x ver %d flags 0x%x phnum %d phoff %016lx phentsize 0x%02x shnum %d shoff %016lx shentsize 0x%02x shstrndx %d\n",
+        ehdr.e_type, ehdr.e_machine, ehdr.e_version, ehdr.e_flags, phnum, ehdr.e_phoff, ehdr.e_phentsize, shnum, ehdr.e_shoff, ehdr.e_shentsize, ehdr.e_shstrndx);
+
+    if (ehdr.e_phoff != 0 && phnum > 0)
+    {
+        Phdr* phdrAddr = reinterpret_cast<Phdr*>(baseAddress + ehdr.e_phoff);
+
+        // Add the program headers and search for the module's note and unwind info segments
+        for (int i = 0; i < phnum; i++, phdrAddr++)
+        {
+            Phdr ph;
+            if (!ReadMemory(phdrAddr, &ph, sizeof(ph))) {
+                fprintf(stderr, "ReadMemory(%p, %lx) phdr FAILED\n", phdrAddr, sizeof(ph));
+                return false;
+            }
+            TRACE("ELF: phdr %p type %d (%x) vaddr %016lx memsz %016lx paddr %016lx filesz %016lx offset %016lx align %016lx\n",
+                phdrAddr, ph.p_type, ph.p_type, ph.p_vaddr, ph.p_memsz, ph.p_paddr, ph.p_filesz, ph.p_offset, ph.p_align);
+
+            if (ph.p_type == PT_DYNAMIC || ph.p_type == PT_NOTE || ph.p_type == PT_GNU_EH_FRAME)
+            {
+                if (ph.p_vaddr != 0 && ph.p_memsz != 0)
+                {
+                    InsertMemoryRegion(baseAddress + ph.p_vaddr, ph.p_memsz);
+                }
+            }
+        }
+    }
+
+    // Skip the "interpreter" module i.e. /lib64/ld-linux-x86-64.so.2 or ld-2.19.so. The in-memory section headers are 
+    // not valid. Ignore all failures too because on debug builds of coreclr, the section headers are not in valid memory.
+    if (baseAddress != m_auxvValues[AT_BASE] && ehdr.e_shoff != 0 && shnum > 0 && ehdr.e_shstrndx != SHN_UNDEF)
+    {
+        Shdr* shdrAddr = reinterpret_cast<Shdr*>(baseAddress + ehdr.e_shoff);
+
+        // Get the string table section header
+        Shdr stringTableSectionHeader;
+        if (!ReadMemory(shdrAddr + ehdr.e_shstrndx, &stringTableSectionHeader, sizeof(stringTableSectionHeader))) {
+            TRACE("ELF: %2d shdr %p ReadMemory string table section header FAILED\n", ehdr.e_shstrndx, shdrAddr + ehdr.e_shstrndx);
+            return true;
+        }
+        // Get the string table
+        ArrayHolder<char> stringTable = new char[stringTableSectionHeader.sh_size];
+        if (!ReadMemory((void*)(baseAddress + stringTableSectionHeader.sh_offset), stringTable.GetPtr(), stringTableSectionHeader.sh_size)) {
+            TRACE("ELF: %2d shdr %p ReadMemory string table FAILED\n", ehdr.e_shstrndx, (void*)(baseAddress + stringTableSectionHeader.sh_offset));
+            return true;
+        }
+        // Add the section headers to the core dump
+        for (int sectionIndex = 0; sectionIndex < shnum; sectionIndex++, shdrAddr++)
+        {
+            Shdr sh;
+            if (!ReadMemory(shdrAddr, &sh, sizeof(sh))) {
+                TRACE("ELF: %2d shdr %p ReadMemory FAILED\n", sectionIndex, shdrAddr);
+                return true;
+            }
+            TRACE("ELF: %2d shdr %p type %2d (%x) addr %016lx offset %016lx size %016lx link %08x info %08x name %4d %s\n",
+                sectionIndex, shdrAddr, sh.sh_type, sh.sh_type, sh.sh_addr, sh.sh_offset, sh.sh_size, sh.sh_link, sh.sh_info, sh.sh_name, &stringTable[sh.sh_name]);
+
+            if (sh.sh_name != SHN_UNDEF && sh.sh_offset > 0 && sh.sh_size > 0) {
+                char* name = &stringTable[sh.sh_name];
+
+                // Add the .eh_frame/.eh_frame_hdr unwind info to the core dump
+                if (NameCompare(name, ".eh_frame") ||
+                    NameCompare(name, ".eh_frame_hdr") ||
+                    NameCompare(name, ".note.gnu.build-id") ||
+                    NameCompare(name, ".note.gnu.ABI-tag") ||
+                    NameCompare(name, ".gnu_debuglink"))
+                {
+                    TRACE("ELF: %s %p size %016lx\n", name, (void*)(baseAddress + sh.sh_offset), sh.sh_size);
+                    InsertMemoryRegion(baseAddress + sh.sh_offset, sh.sh_size);
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+//
+// Enumerate all the memory regions using the DAC memory region support given a minidump type
+//
 bool
 CrashInfo::EnumerateMemoryRegionsWithDAC(const char* programPath, MINIDUMP_TYPE minidumpType)
 {
     PFN_CLRDataCreateInstance pfnCLRDataCreateInstance = nullptr;
-    ICLRDataEnumMemoryRegions *clrDataEnumRegions = nullptr;
+    ICLRDataEnumMemoryRegions* clrDataEnumRegions = nullptr;
+    IXCLRDataProcess* clrDataProcess = nullptr;
     HMODULE hdac = nullptr;
     HRESULT hr = S_OK;
     bool result = false;
@@ -475,7 +625,7 @@ CrashInfo::EnumerateMemoryRegionsWithDAC(const char* programPath, MINIDUMP_TYPE
     dacPath.append(programPath);
     dacPath.append("/");
     dacPath.append(MAKEDLLNAME_A("mscordaccore"));
-    
+
     // Load and initialize the DAC
     hdac = LoadLibraryA(dacPath.c_str());
     if (hdac == nullptr)
@@ -489,17 +639,30 @@ CrashInfo::EnumerateMemoryRegionsWithDAC(const char* programPath, MINIDUMP_TYPE
         fprintf(stderr, "GetProcAddress(CLRDataCreateInstance) FAILED %d\n", GetLastError());
         goto exit;
     }
-    hr = pfnCLRDataCreateInstance(__uuidof(ICLRDataEnumMemoryRegions), m_dataTarget, (void**)&clrDataEnumRegions);
+    if ((minidumpType & MiniDumpWithFullMemory) == 0)
+    {
+        hr = pfnCLRDataCreateInstance(__uuidof(ICLRDataEnumMemoryRegions), m_dataTarget, (void**)&clrDataEnumRegions);
+        if (FAILED(hr))
+        {
+            fprintf(stderr, "CLRDataCreateInstance(ICLRDataEnumMemoryRegions) FAILED %08x\n", hr);
+            goto exit;
+        }
+        // Calls CrashInfo::EnumMemoryRegion for each memory region found by the DAC
+        hr = clrDataEnumRegions->EnumMemoryRegions(this, minidumpType, CLRDATA_ENUM_MEM_DEFAULT);
+        if (FAILED(hr))
+        {
+            fprintf(stderr, "EnumMemoryRegions FAILED %08x\n", hr);
+            goto exit;
+        }
+    }
+    hr = pfnCLRDataCreateInstance(__uuidof(IXCLRDataProcess), m_dataTarget, (void**)&clrDataProcess);
     if (FAILED(hr))
     {
-        fprintf(stderr, "CLRDataCreateInstance(ICLRDataEnumMemoryRegions) FAILED %08x\n", hr);
+        fprintf(stderr, "CLRDataCreateInstance(IXCLRDataProcess) FAILED %08x\n", hr);
         goto exit;
     }
-    // Calls CrashInfo::EnumMemoryRegion for each memory region found by the DAC
-    hr = clrDataEnumRegions->EnumMemoryRegions(this, minidumpType, CLRDATA_ENUM_MEM_DEFAULT);
-    if (FAILED(hr))
+    if (!EnumerateManagedModules(clrDataProcess))
     {
-        fprintf(stderr, "EnumMemoryRegions FAILED %08x\n", hr);
         goto exit;
     }
     result = true;
@@ -508,6 +671,10 @@ exit:
     {
         clrDataEnumRegions->Release();
     }
+    if (clrDataProcess != nullptr)
+    {
+        clrDataProcess->Release();
+    }
     if (hdac != nullptr)
     {
         FreeLibrary(hdac);
@@ -516,6 +683,104 @@ exit:
 }
 
 //
+// Enumerate all the managed modules and replace the module 
+// mapping with the module name found.
+//
+bool
+CrashInfo::EnumerateManagedModules(IXCLRDataProcess* clrDataProcess)
+{
+    IXCLRDataModule* clrDataModule = nullptr;
+    CLRDATA_ENUM enumModules = 0;
+    HRESULT hr = S_OK;
+
+    if (FAILED(hr = clrDataProcess->StartEnumModules(&enumModules))) {
+        fprintf(stderr, "StartEnumModules FAILED %08x\n", hr);
+        return false;
+    }
+    while ((hr = clrDataProcess->EnumModule(&enumModules, &clrDataModule)) == S_OK)
+    {
+        DacpGetModuleData moduleData;
+        if (SUCCEEDED(hr = moduleData.Request(clrDataModule)))
+        {
+            TRACE("MODULE: %016lx dyn %d inmem %d file %d pe %016lx pdb %016lx", moduleData.LoadedPEAddress, moduleData.IsDynamic, 
+                moduleData.IsInMemory, moduleData.IsFileLayout, moduleData.PEFile, moduleData.InMemoryPdbAddress);
+
+            if (!moduleData.IsDynamic && moduleData.LoadedPEAddress != 0)
+            {
+                ArrayHolder<WCHAR> wszUnicodeName = new WCHAR[MAX_LONGPATH + 1];
+                if (SUCCEEDED(hr = clrDataModule->GetFileName(MAX_LONGPATH, NULL, wszUnicodeName)))
+                {
+                    char* pszName = (char*)malloc(MAX_LONGPATH + 1);
+                    if (pszName == nullptr) {
+                        fprintf(stderr, "Allocating module name FAILED\n");
+                        return false;
+                    }
+                    sprintf_s(pszName, MAX_LONGPATH, "%S", (WCHAR*)wszUnicodeName);
+                    TRACE(" %s\n", pszName);
+
+                    // Change the module mapping name
+                    ReplaceModuleMapping(moduleData.LoadedPEAddress, pszName);
+                }
+                else {
+                    TRACE("\nModule.GetFileName FAILED %08x\n", hr);
+                }
+            }
+            else {
+                TRACE("\n");
+            }
+        }
+        else {
+            TRACE("moduleData.Request FAILED %08x\n", hr);
+        }
+        if (clrDataModule != nullptr) {
+            clrDataModule->Release();
+        }
+    }
+    if (enumModules != 0) {
+        clrDataProcess->EndEnumModules(enumModules);
+    }
+    return true;
+}
+
+//
+// Replace an existing module mapping with one with a different name.
+//
+void
+CrashInfo::ReplaceModuleMapping(CLRDATA_ADDRESS baseAddress, const char* pszName)
+{
+    // Add or change the module mapping for this PE image. The managed assembly images are
+    // already in the module mappings list but in .NET 2.0 they have the name "/dev/zero".
+    MemoryRegion region(PF_R | PF_W | PF_X, baseAddress, baseAddress + PAGE_SIZE, 0, pszName);
+    const auto& found = m_moduleMappings.find(region);
+    if (found == m_moduleMappings.end())
+    {
+        m_moduleMappings.insert(region);
+
+        if (g_diagnostics) {
+            TRACE("MODULE: ADD ");
+            region.Trace();
+        }
+    }
+    else
+    {
+        // Create the new memory region with the managed assembly name.
+        MemoryRegion newRegion(*found, pszName);
+
+        // Remove and cleanup the old one
+        m_moduleMappings.erase(found);
+        const_cast<MemoryRegion&>(*found).Cleanup();
+
+        // Add the new memory region
+        m_moduleMappings.insert(newRegion);
+
+        if (g_diagnostics) {
+            TRACE("MODULE: REPLACE ");
+            newRegion.Trace();
+        }
+    }
+}
+
+//
 // ReadMemory from target and add to memory regions list
 //
 bool
@@ -524,7 +789,6 @@ CrashInfo::ReadMemory(void* address, void* buffer, size_t size)
     uint32_t read = 0;
     if (FAILED(m_dataTarget->ReadVirtual(reinterpret_cast<CLRDATA_ADDRESS>(address), reinterpret_cast<PBYTE>(buffer), size, &read)))
     {
-        fprintf(stderr, "ReadMemory(%p, %lx) FAILED\n", address, size);
         return false;
     }
     InsertMemoryRegion(reinterpret_cast<uint64_t>(address), size);
@@ -538,6 +802,8 @@ CrashInfo::ReadMemory(void* address, void* buffer, size_t size)
 void
 CrashInfo::InsertMemoryRegion(uint64_t address, size_t size)
 {
+    assert(size < UINT_MAX);
+
     // Round to page boundary
     uint64_t start = address & PAGE_MASK;
     assert(start > 0);
@@ -546,8 +812,16 @@ CrashInfo::InsertMemoryRegion(uint64_t address, size_t size)
     uint64_t end = ((address + size) + (PAGE_SIZE - 1)) & PAGE_MASK;
     assert(end > 0);
 
-    MemoryRegion region(start, end);
-    InsertMemoryRegion(region);
+    InsertMemoryRegion(MemoryRegion(GetMemoryRegionFlags(start) | MEMORY_REGION_FLAG_MEMORY_BACKED, start, end));
+}
+
+//
+// Adds a memory backed flagged copy of the memory region. The file name is not preserved.
+//
+void
+CrashInfo::InsertMemoryBackedRegion(const MemoryRegion& region)
+{
+    InsertMemoryRegion(MemoryRegion(region, region.Flags() | MEMORY_REGION_FLAG_MEMORY_BACKED));
 }
 
 //
@@ -556,52 +830,88 @@ CrashInfo::InsertMemoryRegion(uint64_t address, size_t size)
 void
 CrashInfo::InsertMemoryRegion(const MemoryRegion& region)
 {
-    // First check if the full memory region can be added without conflicts
+    // First check if the full memory region can be added without conflicts and is fully valid.
     const auto& found = m_memoryRegions.find(region);
     if (found == m_memoryRegions.end())
     {
-        // Add full memory region
-        m_memoryRegions.insert(region);
+        // If the region is valid, add the full memory region
+        if (ValidRegion(region)) {
+            m_memoryRegions.insert(region);
+            return;
+        }
     }
     else
     {
-        // The memory region is not wholely contained in region found
-        if (!found->Contains(region))
-        {
-            uint64_t start = region.StartAddress();
+        // If the memory region is wholly contained in region found and both have the 
+        // same backed by memory state, we're done.
+        if (found->Contains(region) && (found->IsBackedByMemory() == region.IsBackedByMemory())) {
+            return;
+        }
+    }
+    // Either part of the region was invalid, part of it hasn't been added or the backed
+    // by memory state is different.
+    uint64_t start = region.StartAddress();
 
-            // The region overlaps/conflicts with one already in the set so 
-            // add one page at a time to avoid the overlapping pages.
-            uint64_t numberPages = region.Size() >> PAGE_SHIFT;
+    // The region overlaps/conflicts with one already in the set so add one page at a 
+    // time to avoid the overlapping pages.
+    uint64_t numberPages = region.Size() >> PAGE_SHIFT;
 
-            for (int p = 0; p < numberPages; p++, start += PAGE_SIZE)
-            {
-                MemoryRegion memoryRegionPage(start, start + PAGE_SIZE);
+    for (int p = 0; p < numberPages; p++, start += PAGE_SIZE)
+    {
+        MemoryRegion memoryRegionPage(region.Flags(), start, start + PAGE_SIZE);
 
-                const auto& found = m_memoryRegions.find(memoryRegionPage);
-                if (found == m_memoryRegions.end())
-                {
-                    m_memoryRegions.insert(memoryRegionPage);
-                }
+        const auto& found = m_memoryRegions.find(memoryRegionPage);
+        if (found == m_memoryRegions.end())
+        {
+            // All the single pages added here will be combined in CombineMemoryRegions()
+            if (ValidRegion(memoryRegionPage)) {
+                m_memoryRegions.insert(memoryRegionPage);
             }
         }
+        else {
+            assert(found->IsBackedByMemory() || !region.IsBackedByMemory());
+        }
     }
 }
 
+//
+// Get the memory region flags for a start address
+//
+uint32_t 
+CrashInfo::GetMemoryRegionFlags(uint64_t start)
+{
+    const MemoryRegion* region = SearchMemoryRegions(m_moduleMappings, start);
+    if (region != nullptr) {
+        return region->Flags();
+    }
+    region = SearchMemoryRegions(m_otherMappings, start);
+    if (region != nullptr) {
+        return region->Flags();
+    }
+    TRACE("GetMemoryRegionFlags: FAILED\n");
+    return PF_R | PF_W | PF_X;
+}
+
+//
+// Validates a memory region
+//
 bool
 CrashInfo::ValidRegion(const MemoryRegion& region)
 {
-    uint64_t start = region.StartAddress();
-    uint64_t numberPages = region.Size() >> PAGE_SHIFT;
-
-    for (int p = 0; p < numberPages; p++, start += PAGE_SIZE)
+    if (region.IsBackedByMemory())
     {
-        BYTE buffer[1];
-        uint32_t read;
+        uint64_t start = region.StartAddress();
+        uint64_t numberPages = region.Size() >> PAGE_SHIFT;
 
-        if (FAILED(m_dataTarget->ReadVirtual(start, buffer, 1, &read)))
+        for (int p = 0; p < numberPages; p++, start += PAGE_SIZE)
         {
-            return false;
+            BYTE buffer[1];
+            uint32_t read;
+
+            if (FAILED(m_dataTarget->ReadVirtual(start, buffer, 1, &read)))
+            {
+                return false;
+            }
         }
     }
     return true;
@@ -617,28 +927,34 @@ CrashInfo::CombineMemoryRegions()
 
     std::set<MemoryRegion> memoryRegionsNew;
 
+    // MEMORY_REGION_FLAG_SHARED and MEMORY_REGION_FLAG_PRIVATE are internal flags that 
+    // don't affect the core dump so ignore them when comparing the flags.
+    uint32_t flags = m_memoryRegions.begin()->Flags() & (MEMORY_REGION_FLAG_MEMORY_BACKED | MEMORY_REGION_FLAG_PERMISSIONS_MASK);
     uint64_t start = m_memoryRegions.begin()->StartAddress();
     uint64_t end = start;
 
     for (const MemoryRegion& region : m_memoryRegions)
     {
-        if (end == region.StartAddress())
+        // To combine a region it needs to be contiguous, same permissions and memory backed flag.
+        if ((end == region.StartAddress()) && 
+            (flags == (region.Flags() & (MEMORY_REGION_FLAG_MEMORY_BACKED | MEMORY_REGION_FLAG_PERMISSIONS_MASK))))
         {
             end = region.EndAddress();
         }
         else
         {
-            MemoryRegion memoryRegion(start, end);
+            MemoryRegion memoryRegion(flags, start, end);
             assert(memoryRegionsNew.find(memoryRegion) == memoryRegionsNew.end());
             memoryRegionsNew.insert(memoryRegion);
 
+            flags = region.Flags() & (MEMORY_REGION_FLAG_MEMORY_BACKED | MEMORY_REGION_FLAG_PERMISSIONS_MASK);
             start = region.StartAddress();
             end = region.EndAddress();
         }
     }
 
     assert(start != end);
-    MemoryRegion memoryRegion(start, end);
+    MemoryRegion memoryRegion(flags, start, end);
     assert(memoryRegionsNew.find(memoryRegion) == memoryRegionsNew.end());
     memoryRegionsNew.insert(memoryRegion);
 
@@ -649,11 +965,31 @@ CrashInfo::CombineMemoryRegions()
         TRACE("Memory Regions:\n");
         for (const MemoryRegion& region : m_memoryRegions)
         {
-            region.Print();
+            region.Trace();
+        }
+    }
+}
+
+//
+// Searches for a memory region given an address.
+//
+const MemoryRegion* 
+CrashInfo::SearchMemoryRegions(const std::set<MemoryRegion>& regions, uint64_t start)
+{
+    std::set<MemoryRegion>::iterator found = regions.find(MemoryRegion(0, start, start + PAGE_SIZE));
+    for (; found != regions.end(); found++)
+    {
+        if (start >= found->StartAddress() && start < found->EndAddress())
+        {
+            return &*found;
         }
     }
+	return nullptr;
 }
 
+//
+// Get the process or thread status
+//
 bool
 CrashInfo::GetStatus(pid_t pid, pid_t* ppid, pid_t* tgid, char** name)
 {
diff --git a/src/debug/createdump/crashinfo.h b/src/debug/createdump/crashinfo.h
index 914a88e8dd..43e82691aa 100644
--- a/src/debug/createdump/crashinfo.h
+++ b/src/debug/createdump/crashinfo.h
@@ -38,6 +38,7 @@ public:
     bool GatherCrashInfo(const char* programPath, MINIDUMP_TYPE minidumpType);
     void ResumeThreads();
     static bool GetStatus(pid_t pid, pid_t* ppid, pid_t* tgid, char** name);
+    static const MemoryRegion* SearchMemoryRegions(const std::set<MemoryRegion>& regions, uint64_t start);
 
     const pid_t Pid() const { return m_pid; }
     const pid_t Ppid() const { return m_ppid; }
@@ -46,9 +47,9 @@ public:
     ICLRDataTarget* DataTarget() const { return m_dataTarget; }
 
     const std::vector<ThreadInfo*> Threads() const { return m_threads; }
-    const std::set<MemoryRegion> ModuleMappings()  const { return m_moduleMappings; }
-    const std::set<MemoryRegion> OtherMappings()  const { return m_otherMappings; }
-    const std::set<MemoryRegion> MemoryRegions()  const { return m_memoryRegions; }
+    const std::set<MemoryRegion> ModuleMappings() const { return m_moduleMappings; }
+    const std::set<MemoryRegion> OtherMappings() const { return m_otherMappings; }
+    const std::set<MemoryRegion> MemoryRegions() const { return m_memoryRegions; }
     const std::vector<elf_aux_entry> AuxvEntries() const { return m_auxvEntries; }
     const size_t GetAuxvSize() const { return m_auxvEntries.size() * sizeof(elf_aux_entry); }
 
@@ -58,18 +59,21 @@ public:
     STDMETHOD_(ULONG, Release)();
 
     // ICLRDataEnumMemoryRegionsCallback
-    virtual HRESULT STDMETHODCALLTYPE EnumMemoryRegion( 
-        /* [in] */ CLRDATA_ADDRESS address,
-        /* [in] */ ULONG32 size);
+    virtual HRESULT STDMETHODCALLTYPE EnumMemoryRegion(/* [in] */ CLRDATA_ADDRESS address, /* [in] */ ULONG32 size);
 
 private:
     bool GetAuxvEntries();
     bool EnumerateModuleMappings();
     bool GetDSOInfo();
+    bool GetELFInfo(uint64_t baseAddress);
     bool EnumerateMemoryRegionsWithDAC(const char* programPath, MINIDUMP_TYPE minidumpType);
+    bool EnumerateManagedModules(IXCLRDataProcess* clrDataProcess);
+    void ReplaceModuleMapping(CLRDATA_ADDRESS baseAddress, const char* pszName);
     bool ReadMemory(void* address, void* buffer, size_t size);
+    void InsertMemoryBackedRegion(const MemoryRegion& region);
     void InsertMemoryRegion(uint64_t address, size_t size);
     void InsertMemoryRegion(const MemoryRegion& region);
+    uint32_t GetMemoryRegionFlags(uint64_t start);
     bool ValidRegion(const MemoryRegion& region);
     void CombineMemoryRegions();
 };
diff --git a/src/debug/createdump/createdump.h b/src/debug/createdump/createdump.h
index 38c3525f34..6f72f0e955 100644
--- a/src/debug/createdump/createdump.h
+++ b/src/debug/createdump/createdump.h
@@ -33,6 +33,8 @@ extern bool g_diagnostics;
 #include <xcordebug.h>
 #include <mscoree.h>
 #include <dumpcommon.h>
+typedef int T_CONTEXT;
+#include <dacprivate.h>
 #include <arrayholder.h>
 #include <releaseholder.h>
 #include <unistd.h>
@@ -54,4 +56,4 @@ extern bool g_diagnostics;
 #include "threadinfo.h"
 #include "memoryregion.h"
 #include "crashinfo.h"
-#include "dumpwriter.h"
\ No newline at end of file
+#include "dumpwriter.h"
diff --git a/src/debug/createdump/dumpwriter.cpp b/src/debug/createdump/dumpwriter.cpp
index 69f0ece8af..06c5b96d01 100644
--- a/src/debug/createdump/dumpwriter.cpp
+++ b/src/debug/createdump/dumpwriter.cpp
@@ -91,14 +91,9 @@ DumpWriter::WriteDump()
     ehdr.e_ident[1] = ELFMAG1;
     ehdr.e_ident[2] = ELFMAG2;
     ehdr.e_ident[3] = ELFMAG3;
-    ehdr.e_ident[4] = ELF_CLASS;
-
-    // Note: The sex is the current system running minidump-2-core
-    //       Big or Little endian.  This means you have to create
-    //       the core (minidump-2-core) on the system that matches
-    //       your intent to debug properly.
-    ehdr.e_ident[5] = sex() ? ELFDATA2MSB : ELFDATA2LSB;
-    ehdr.e_ident[6] = EV_CURRENT;
+    ehdr.e_ident[EI_CLASS] = ELF_CLASS;
+    ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
+    ehdr.e_ident[EI_VERSION] = EV_CURRENT;
     ehdr.e_ident[EI_OSABI] = ELFOSABI_LINUX;
 
     ehdr.e_type = ET_CORE;
@@ -180,9 +175,17 @@ DumpWriter::WriteDump()
         phdr.p_vaddr = memoryRegion.StartAddress();
         phdr.p_memsz = memoryRegion.Size();
 
-        offset += filesz;
-        phdr.p_filesz = filesz = memoryRegion.Size();
-        phdr.p_offset = offset;
+        if (memoryRegion.IsBackedByMemory())
+        {
+            offset += filesz;
+            phdr.p_filesz = filesz = memoryRegion.Size();
+            phdr.p_offset = offset;
+        }
+        else 
+        {
+            phdr.p_filesz = 0;
+            phdr.p_offset = 0;
+        }
 
         if (!WriteData(&phdr, sizeof(phdr))) {
             return false;
@@ -230,26 +233,30 @@ DumpWriter::WriteDump()
     uint64_t total = 0;
     for (const MemoryRegion& memoryRegion : m_crashInfo.MemoryRegions())
     {
-        uint32_t size = memoryRegion.Size();
-        uint64_t address = memoryRegion.StartAddress();
-        total += size;
-
-        while (size > 0)
+        // Only write the regions that are backed by memory
+        if (memoryRegion.IsBackedByMemory())
         {
-            uint32_t bytesToRead = std::min(size, (uint32_t)sizeof(m_tempBuffer));
-            uint32_t read = 0;
-
-            if (FAILED(m_crashInfo.DataTarget()->ReadVirtual(address, m_tempBuffer, bytesToRead, &read))) {
-                fprintf(stderr, "ReadVirtual(%016lx, %08x) FAILED\n", address, bytesToRead);
-                return false;
-            }
-
-            if (!WriteData(m_tempBuffer, read)) {
-                return false;
+            uint32_t size = memoryRegion.Size();
+            uint64_t address = memoryRegion.StartAddress();
+            total += size;
+
+            while (size > 0)
+            {
+                uint32_t bytesToRead = std::min(size, (uint32_t)sizeof(m_tempBuffer));
+                uint32_t read = 0;
+
+                if (FAILED(m_crashInfo.DataTarget()->ReadVirtual(address, m_tempBuffer, bytesToRead, &read))) {
+                    fprintf(stderr, "ReadVirtual(%016lx, %08x) FAILED\n", address, bytesToRead);
+                    return false;
+                }
+
+                if (!WriteData(m_tempBuffer, read)) {
+                    return false;
+                }
+
+                address += read;
+                size -= read;
             }
-
-            address += read;
-            size -= read;
         }
     }
 
diff --git a/src/debug/createdump/dumpwriter.h b/src/debug/createdump/dumpwriter.h
index 0b4f88cbd6..7da0d63ccf 100644
--- a/src/debug/createdump/dumpwriter.h
+++ b/src/debug/createdump/dumpwriter.h
@@ -69,9 +69,3 @@ private:
         );
     }
 };
-
-static inline int sex()
-{
-  int probe = 1;
-  return !*(char *)&probe;
-}
diff --git a/src/debug/createdump/memoryregion.h b/src/debug/createdump/memoryregion.h
index 1332ab1416..1f6c5f53e6 100644
--- a/src/debug/createdump/memoryregion.h
+++ b/src/debug/createdump/memoryregion.h
@@ -2,20 +2,31 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+enum MEMORY_REGION_FLAGS : uint32_t
+{
+    // PF_X        = 0x01,      // Execute
+    // PF_W        = 0x02,      // Write
+    // PF_R        = 0x04,      // Read
+    MEMORY_REGION_FLAG_PERMISSIONS_MASK = 0x0f,
+    MEMORY_REGION_FLAG_SHARED = 0x10,
+    MEMORY_REGION_FLAG_PRIVATE = 0x20,
+    MEMORY_REGION_FLAG_MEMORY_BACKED = 0x40
+};
+
 struct MemoryRegion 
 {
 private:
-    uint32_t m_permissions;
+    uint32_t m_flags;
     uint64_t m_startAddress;
     uint64_t m_endAddress;
     uint64_t m_offset;
 
     // The name used for NT_FILE output
-    char* m_fileName;
+    const char* m_fileName;
 
 public:
-    MemoryRegion(uint64_t start, uint64_t end) : 
-        m_permissions(PF_R | PF_W | PF_X),
+    MemoryRegion(uint32_t flags, uint64_t start, uint64_t end) : 
+        m_flags(flags),
         m_startAddress(start),
         m_endAddress(end),
         m_offset(0),
@@ -25,8 +36,8 @@ public:
         assert((end & ~PAGE_MASK) == 0);
     }
 
-    MemoryRegion(uint32_t permissions, uint64_t start, uint64_t end, uint64_t offset, char* filename) : 
-        m_permissions(permissions),
+    MemoryRegion(uint32_t flags, uint64_t start, uint64_t end, uint64_t offset, const char* filename) : 
+        m_flags(flags),
         m_startAddress(start),
         m_endAddress(end),
         m_offset(offset),
@@ -36,7 +47,39 @@ public:
         assert((end & ~PAGE_MASK) == 0);
     }
 
-    const uint32_t Permissions() const { return m_permissions; }
+    // copy with new file name constructor
+    MemoryRegion(const MemoryRegion& region, const char* fileName) : 
+        m_flags(region.m_flags),
+        m_startAddress(region.m_startAddress),
+        m_endAddress(region.m_endAddress),
+        m_offset(region.m_offset),
+        m_fileName(fileName)
+    {
+    }
+
+    // copy with new flags constructor. The file name is not copied.
+    MemoryRegion(const MemoryRegion& region, uint32_t flags) : 
+        m_flags(flags),
+        m_startAddress(region.m_startAddress),
+        m_endAddress(region.m_endAddress),
+        m_offset(region.m_offset),
+        m_fileName(nullptr)
+    {
+    }
+
+    // copy constructor
+    MemoryRegion(const MemoryRegion& region) : 
+        m_flags(region.m_flags),
+        m_startAddress(region.m_startAddress),
+        m_endAddress(region.m_endAddress),
+        m_offset(region.m_offset),
+        m_fileName(region.m_fileName)
+    {
+    }
+
+    const uint32_t Permissions() const { return m_flags & MEMORY_REGION_FLAG_PERMISSIONS_MASK; }
+    const uint32_t Flags() const { return m_flags; }
+    const bool IsBackedByMemory() const { return (m_flags & MEMORY_REGION_FLAG_MEMORY_BACKED) != 0; }
     const uint64_t StartAddress() const { return m_startAddress; }
     const uint64_t EndAddress() const { return m_endAddress; }
     const uint64_t Size() const { return m_endAddress - m_startAddress; }
@@ -48,27 +91,25 @@ public:
         return (m_startAddress < rhs.m_startAddress) && (m_endAddress <= rhs.m_startAddress);
     }
 
+    // Returns true if "rhs" is wholly contained in this one
     bool Contains(const MemoryRegion& rhs) const
     {
         return (m_startAddress <= rhs.m_startAddress) && (m_endAddress >= rhs.m_endAddress);
     }
 
+    // Free the file name memory
     void Cleanup()
     {
         if (m_fileName != nullptr)
         {
-            free(m_fileName);
+            free((void*)m_fileName);
             m_fileName = nullptr;
         }
     }
 
-    void Print() const
+    void Trace() const
     {
-        if (m_fileName != nullptr) {
-            TRACE("%016lx - %016lx (%06ld) %016lx %x %s\n", m_startAddress, m_endAddress, (Size() >> PAGE_SHIFT), m_offset, m_permissions, m_fileName);
-        }
-        else {
-            TRACE("%016lx - %016lx (%06ld) %x\n", m_startAddress, m_endAddress, (Size() >> PAGE_SHIFT), m_permissions);
-        }
+        TRACE("%s%016lx - %016lx (%06ld) %016lx %02x %s\n", IsBackedByMemory() ? "*" : " ", m_startAddress, m_endAddress, 
+            (Size() >> PAGE_SHIFT), m_offset, m_flags, m_fileName != nullptr ? m_fileName : "");
     }
 };
diff --git a/src/debug/createdump/threadinfo.cpp b/src/debug/createdump/threadinfo.cpp
index e2c10fc4b7..35a4f0d4cd 100644
--- a/src/debug/createdump/threadinfo.cpp
+++ b/src/debug/createdump/threadinfo.cpp
@@ -145,21 +145,19 @@ ThreadInfo::GetThreadStack(const CrashInfo& crashInfo, uint64_t* startAddress, s
     *startAddress = m_gpRegisters.rsp & PAGE_MASK;
     *size = 4 * PAGE_SIZE;
 
-    for (const MemoryRegion& mapping : crashInfo.OtherMappings())
-    {
-        if (*startAddress >= mapping.StartAddress() && *startAddress < mapping.EndAddress())
+    const MemoryRegion* region = CrashInfo::SearchMemoryRegions(crashInfo.OtherMappings(), *startAddress);
+    if (region != nullptr) {
+
+        // Use the mapping found for the size of the thread's stack
+        *size = region->EndAddress() - *startAddress;
+
+        if (g_diagnostics)
         {
-            // Use the mapping found for the size of the thread's stack
-            *size = mapping.EndAddress() - *startAddress;
-
-            if (g_diagnostics)
-            {
-                TRACE("Thread %04x stack found in other mapping (size %08lx): ", m_tid, *size);
-                mapping.Print();
-            }
-            break;
+            TRACE("Thread %04x stack found in other mapping (size %08lx): ", m_tid, *size);
+            region->Trace();
         }
     }
+    
 }
 
 void
diff --git a/src/jit/lower.cpp b/src/jit/lower.cpp
index 72dba4ee7e..9cab5eecf2 100644
--- a/src/jit/lower.cpp
+++ b/src/jit/lower.cpp
@@ -1723,14 +1723,14 @@ void Lowering::LowerFastTailCall(GenTreeCall* call)
                     {
                         tmpLclNum = comp->lvaGrabTemp(
                             true DEBUGARG("Fast tail call lowering is creating a new local variable"));
-                        comp->lvaSortAgain                 = true;
-                        tmpType                            = genActualType(callerArgDsc->lvaArgType());
-                        comp->lvaTable[tmpLclNum].lvType   = tmpType;
-                        comp->lvaTable[tmpLclNum].lvRefCnt = 1;
+                        comp->lvaSortAgain                          = true;
+                        tmpType                                     = genActualType(callerArgDsc->lvaArgType());
+                        comp->lvaTable[tmpLclNum].lvType            = tmpType;
+                        comp->lvaTable[tmpLclNum].lvRefCnt          = 1;
+                        comp->lvaTable[tmpLclNum].lvDoNotEnregister = comp->lvaTable[lcl->gtLclNum].lvDoNotEnregister;
                     }
 
                     lcl->SetLclNum(tmpLclNum);
-                    lcl->SetOper(GT_LCL_VAR);
                 }
             }
         }
diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp
index 6928c3c393..9404469c7f 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -7529,6 +7529,39 @@ void Compiler::fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCa
         fgInsertStmtBefore(block, paramAssignmentInsertionPoint, arg0AssignmentStmt);
     }
 
+    // If compInitMem is set, we may need to zero-initialize some locals. Normally it's done in the prolog
+    // but this loop can't include the prolog. Since we don't have liveness information, we insert zero-initialization
+    // for all non-parameter non-temp locals. Liveness phase will remove unnecessary initializations.
+    if (info.compInitMem)
+    {
+        unsigned   varNum;
+        LclVarDsc* varDsc;
+        for (varNum = 0, varDsc = lvaTable; varNum < info.compLocalsCount; varNum++, varDsc++)
+        {
+            if (!varDsc->lvIsParam)
+            {
+                assert(!varDsc->lvIsTemp);
+                var_types  lclType = varDsc->TypeGet();
+                GenTreePtr lcl     = gtNewLclvNode(varNum, lclType);
+                GenTreePtr init    = nullptr;
+                if (lclType == TYP_STRUCT)
+                {
+                    const bool isVolatile  = false;
+                    const bool isCopyBlock = false;
+                    init = gtNewBlkOpNode(lcl, gtNewIconNode(0), varDsc->lvSize(), isVolatile, isCopyBlock);
+                    init = fgMorphInitBlock(init);
+                }
+                else
+                {
+                    GenTreePtr zero = gtNewZeroConNode(genActualType(lclType));
+                    init            = gtNewAssignNode(lcl, zero);
+                }
+                GenTreePtr initStmt = gtNewStmt(init, callILOffset);
+                fgInsertStmtBefore(block, last, initStmt);
+            }
+        }
+    }
+
     // Remove the call
     fgRemoveStmt(block, last);
 
@@ -10514,6 +10547,43 @@ GenTree* Compiler::fgMorphForRegisterFP(GenTree* tree)
     return tree;
 }
 
+//--------------------------------------------------------------------------------------------------------------
+// fgMorphRecognizeBoxNullable:
+//   Recognize this pattern:
+//
+//   stmtExpr  void  (IL 0x000...  ???)
+//     return    int
+//             CNS_INT     ref    null
+//         EQ/NE/GT        int
+//             CALL help ref    HELPER.CORINFO_HELP_BOX_NULLABLE
+//                 CNS_INT(h)  long   0x7fed96836c8 class
+//                 ADDR      byref
+//                     FIELD struct value
+//                         LCL_VAR ref V00 this
+//
+//   which comes from this code:
+//
+//      return this.value==null;
+//
+//   and transform it into
+//
+//   stmtExpr  void  (IL 0x000...  ???)
+//     return    int
+//             CNS_INT     ref    null
+//         EQ/NE/GT        int
+//             IND bool
+//                 ADDR      byref
+//                     FIELD struct value
+//                         LCL_VAR ref V00 this
+//
+// Arguments:
+//       compare - Compare tree to optimize.
+//
+// return value:
+//       A tree that has a call to CORINFO_HELP_BOX_NULLABLE optimized away if the pattern is found;
+//       the original tree otherwise.
+//
+
 GenTree* Compiler::fgMorphRecognizeBoxNullable(GenTree* compare)
 {
     GenTree*     op1 = compare->gtOp.gtOp1;
@@ -10521,26 +10591,6 @@ GenTree* Compiler::fgMorphRecognizeBoxNullable(GenTree* compare)
     GenTree*     opCns;
     GenTreeCall* opCall;
 
-    // recognize this pattern:
-    //
-    // stmtExpr  void  (IL 0x000...  ???)
-    //     return    int
-    //             const     ref    null
-    //         ==        int
-    //             call help ref    HELPER.CORINFO_HELP_BOX_NULLABLE
-    //                 const(h)  long   0x7fed96836c8 class
-    //                 addr      byref
-    //                     ld.lclVar struct V00 arg0
-    //
-    //
-    // which comes from this code (reported by customer as being slow) :
-    //
-    // private static bool IsNull<T>(T arg)
-    // {
-    //    return arg==null;
-    // }
-    //
-
     if (op1->IsCnsIntOrI() && op2->IsHelperCall())
     {
         opCns  = op1;
@@ -10566,8 +10616,17 @@ GenTree* Compiler::fgMorphRecognizeBoxNullable(GenTree* compare)
         return compare;
     }
 
-    // replace the box with an access of the nullable 'hasValue' field which is at the zero offset
-    GenTree* newOp = gtNewOperNode(GT_IND, TYP_BOOL, opCall->gtCall.gtCallArgs->gtOp.gtOp2->gtOp.gtOp1);
+    // Get the nullable struct argument
+    GenTree* arg = opCall->gtCall.gtCallArgs->gtOp.gtOp2->gtOp.gtOp1;
+
+    // Check for cases that are unsafe to optimize and return the unchanged tree
+    if (arg->IsArgPlaceHolderNode() || arg->IsNothingNode() || ((arg->gtFlags & GTF_LATE_ARG) != 0))
+    {
+        return compare;
+    }
+
+    // Replace the box with an access of the nullable 'hasValue' field which is at the zero offset
+    GenTree* newOp = gtNewOperNode(GT_IND, TYP_BOOL, arg);
 
     if (opCall == op1)
     {
@@ -11426,7 +11485,17 @@ GenTreePtr Compiler::fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac)
                         }
                     }
                 }
-                fgMorphRecognizeBoxNullable(tree);
+
+                __fallthrough;
+
+            case GT_GT:
+
+                // Try to optimize away calls to CORINFO_HELP_BOX_NULLABLE for GT_EQ, GT_NE, and unsigned GT_GT.
+                if ((oper != GT_GT) || tree->IsUnsigned())
+                {
+                    fgMorphRecognizeBoxNullable(tree);
+                }
+
                 op1 = tree->gtOp.gtOp1;
                 op2 = tree->gtGetOp2IfPresent();
 
diff --git a/src/mscorlib/System.Private.CoreLib.csproj b/src/mscorlib/System.Private.CoreLib.csproj
index 513e002497..18256086d7 100644
--- a/src/mscorlib/System.Private.CoreLib.csproj
+++ b/src/mscorlib/System.Private.CoreLib.csproj
@@ -619,7 +619,6 @@
     <Compile Include="$(BclSourcesRoot)\System\Resources\__HResults.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\FileBasedResourceGroveler.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\IResourceGroveler.cs" />
-    <Compile Include="$(BclSourcesRoot)\System\Resources\LooselyLinkedResourceReference.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\ManifestBasedResourceGroveler.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\ResourceManager.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\ResourceReader.cs" />
diff --git a/src/mscorlib/shared/System/Char.cs b/src/mscorlib/shared/System/Char.cs
index 3fad7a4827..72441763e9 100644
--- a/src/mscorlib/shared/System/Char.cs
+++ b/src/mscorlib/shared/System/Char.cs
@@ -21,6 +21,7 @@ namespace System
 {
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct Char : IComparable, IComparable<Char>, IEquatable<Char>, IConvertible
     {
         //
diff --git a/src/mscorlib/shared/System/Collections/DictionaryEntry.cs b/src/mscorlib/shared/System/Collections/DictionaryEntry.cs
index 290306d006..3c1c0befa3 100644
--- a/src/mscorlib/shared/System/Collections/DictionaryEntry.cs
+++ b/src/mscorlib/shared/System/Collections/DictionaryEntry.cs
@@ -9,10 +9,11 @@ namespace System.Collections
     // A DictionaryEntry holds a key and a value from a dictionary.
     // It is returned by IDictionaryEnumerator::GetEntry().
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct DictionaryEntry
     {
-        private Object _key;
-        private Object _value;
+        private Object _key; // Do not rename (binary serialization)
+        private Object _value; // Do not rename (binary serialization)
 
         // Constructs a new DictionaryEnumerator by setting the Key
         // and Value fields appropriately.
diff --git a/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs b/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs
index fc51af25f8..aeafecd958 100644
--- a/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs
+++ b/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs
@@ -46,10 +46,11 @@ namespace System.Collections.Generic
     // It is used by the IEnumerable<T> implementation for both IDictionary<TKey, TValue>
     // and IReadOnlyDictionary<TKey, TValue>.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct KeyValuePair<TKey, TValue>
     {
-        private TKey key;       // DO NOT change the field name, it's required for compatibility with desktop .NET as it appears in serialization payload.
-        private TValue value;   // DO NOT change the field name, it's required for compatibility with desktop .NET as it appears in serialization payload.
+        private TKey key; // Do not rename (binary serialization)
+        private TValue value; // Do not rename (binary serialization)
 
         public KeyValuePair(TKey key, TValue value)
         {
diff --git a/src/mscorlib/shared/System/DateTime.cs b/src/mscorlib/shared/System/DateTime.cs
index ddb72da77d..4fd9727fcd 100644
--- a/src/mscorlib/shared/System/DateTime.cs
+++ b/src/mscorlib/shared/System/DateTime.cs
@@ -54,6 +54,7 @@ namespace System
     // 
     [StructLayout(LayoutKind.Auto)]
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public partial struct DateTime : IComparable, IFormattable, IConvertible, IComparable<DateTime>, IEquatable<DateTime>, ISerializable
     {
         // Number of 100ns ticks per time unit
@@ -125,8 +126,8 @@ namespace System
         private const UInt64 KindLocalAmbiguousDst = 0xC000000000000000;
         private const Int32 KindShift = 62;
 
-        private const String TicksField = "ticks";
-        private const String DateDataField = "_dateData";
+        private const String TicksField = "ticks"; // Do not rename (binary serialization)
+        private const String DateDataField = "dateData"; // Do not rename (binary serialization)
 
         // The data is stored as an unsigned 64-bit integeter
         //   Bits 01-62: The value of 100-nanosecond ticks where 0 represents 1/1/0001 12:00am, up until the value
diff --git a/src/mscorlib/shared/System/DateTimeOffset.cs b/src/mscorlib/shared/System/DateTimeOffset.cs
index d5ccbd9195..ab35bdb0fe 100644
--- a/src/mscorlib/shared/System/DateTimeOffset.cs
+++ b/src/mscorlib/shared/System/DateTimeOffset.cs
@@ -30,6 +30,7 @@ namespace System
 
     [StructLayout(LayoutKind.Auto)]
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct DateTimeOffset : IComparable, IFormattable, IComparable<DateTimeOffset>, IEquatable<DateTimeOffset>, ISerializable, IDeserializationCallback
     {
         // Constants
@@ -573,8 +574,8 @@ namespace System
                 throw new ArgumentNullException(nameof(info));
             }
 
-            info.AddValue("DateTime", _dateTime);
-            info.AddValue("OffsetMinutes", _offsetMinutes);
+            info.AddValue("DateTime", _dateTime); // Do not rename (binary serialization)
+            info.AddValue("OffsetMinutes", _offsetMinutes); // Do not rename (binary serialization)
         }
 
 
@@ -585,8 +586,8 @@ namespace System
                 throw new ArgumentNullException(nameof(info));
             }
 
-            _dateTime = (DateTime)info.GetValue("DateTime", typeof(DateTime));
-            _offsetMinutes = (Int16)info.GetValue("OffsetMinutes", typeof(Int16));
+            _dateTime = (DateTime)info.GetValue("DateTime", typeof(DateTime)); // Do not rename (binary serialization)
+            _offsetMinutes = (Int16)info.GetValue("OffsetMinutes", typeof(Int16)); // Do not rename (binary serialization)
         }
 
         // Returns the hash code for this DateTimeOffset.
diff --git a/src/mscorlib/shared/System/Globalization/SortVersion.cs b/src/mscorlib/shared/System/Globalization/SortVersion.cs
index 94c04d7063..46e9a833ec 100644
--- a/src/mscorlib/shared/System/Globalization/SortVersion.cs
+++ b/src/mscorlib/shared/System/Globalization/SortVersion.cs
@@ -5,6 +5,7 @@
 namespace System.Globalization
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public sealed class SortVersion : IEquatable<SortVersion>
     {
         private int m_NlsVersion; // Do not rename (binary serialization)
diff --git a/src/mscorlib/shared/System/Reflection/Assembly.cs b/src/mscorlib/shared/System/Reflection/Assembly.cs
index b965c9f7fb..d35ffc7066 100644
--- a/src/mscorlib/shared/System/Reflection/Assembly.cs
+++ b/src/mscorlib/shared/System/Reflection/Assembly.cs
@@ -125,10 +125,7 @@ namespace System.Reflection
         public virtual FileStream[] GetFiles() => GetFiles(getResourceModules: false);
         public virtual FileStream[] GetFiles(bool getResourceModules) { throw NotImplemented.ByDesign; }
 
-        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            throw new PlatformNotSupportedException();
-        }
+        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) { throw NotImplemented.ByDesign; }
 
         public override string ToString()
         {
diff --git a/src/mscorlib/shared/System/Reflection/Module.cs b/src/mscorlib/shared/System/Reflection/Module.cs
index 7822e9ff10..56f83c40d9 100644
--- a/src/mscorlib/shared/System/Reflection/Module.cs
+++ b/src/mscorlib/shared/System/Reflection/Module.cs
@@ -110,10 +110,7 @@ namespace System.Reflection
         public Type ResolveType(int metadataToken) => ResolveType(metadataToken, null, null);
         public virtual Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { throw NotImplemented.ByDesign; }
 
-        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            throw new PlatformNotSupportedException();
-        }
+        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) { throw NotImplemented.ByDesign; }
 
         public override bool Equals(object o) => base.Equals(o);
         public override int GetHashCode() => base.GetHashCode();
diff --git a/src/mscorlib/shared/System/Reflection/ParameterInfo.cs b/src/mscorlib/shared/System/Reflection/ParameterInfo.cs
index fd130e569b..94bfffaa53 100644
--- a/src/mscorlib/shared/System/Reflection/ParameterInfo.cs
+++ b/src/mscorlib/shared/System/Reflection/ParameterInfo.cs
@@ -54,7 +54,46 @@ namespace System.Reflection
 
         public object GetRealObject(StreamingContext context)
         {
-            throw new PlatformNotSupportedException();
+            // Once all the serializable fields have come in we can set up the real
+            // instance based on just two of them (MemberImpl and PositionImpl).
+
+            if (MemberImpl == null)
+                throw new SerializationException(SR.Serialization_InsufficientState);
+
+            ParameterInfo[] args = null;
+
+            switch (MemberImpl.MemberType)
+            {
+                case MemberTypes.Constructor:
+                case MemberTypes.Method:
+                    if (PositionImpl == -1)
+                    {
+                        if (MemberImpl.MemberType == MemberTypes.Method)
+                            return ((MethodInfo)MemberImpl).ReturnParameter;
+                        else
+                            throw new SerializationException(SR.Serialization_BadParameterInfo);
+                    }
+                    else
+                    {
+                        args = ((MethodBase)MemberImpl).GetParametersNoCopy();
+
+                        if (args != null && PositionImpl < args.Length)
+                            return args[PositionImpl];
+                        else
+                            throw new SerializationException(SR.Serialization_BadParameterInfo);
+                    }
+
+                case MemberTypes.Property:
+                    args = ((PropertyInfo)MemberImpl).GetIndexParameters();
+
+                    if (args != null && PositionImpl > -1 && PositionImpl < args.Length)
+                        return args[PositionImpl];
+                    else
+                        throw new SerializationException(SR.Serialization_BadParameterInfo);
+
+                default:
+                    throw new SerializationException(SR.Serialization_NoParameterInfo);
+            }
         }
 
         public override string ToString() => ParameterType.FormatTypeName() + " " + Name;
diff --git a/src/mscorlib/shared/System/StringComparer.cs b/src/mscorlib/shared/System/StringComparer.cs
index b327e770d5..6990378812 100644
--- a/src/mscorlib/shared/System/StringComparer.cs
+++ b/src/mscorlib/shared/System/StringComparer.cs
@@ -6,15 +6,17 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Diagnostics.Contracts;
+using System.Runtime.Serialization;
 
 namespace System
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string>, IEqualityComparer<string>
     {
         private static readonly CultureAwareComparer s_invariantCulture = new CultureAwareComparer(CultureInfo.InvariantCulture, false);
         private static readonly CultureAwareComparer s_invariantCultureIgnoreCase = new CultureAwareComparer(CultureInfo.InvariantCulture, true);
-        private static readonly OrdinalComparer s_ordinal = new OrdinalComparer();
+        private static readonly OrdinalCaseSensitiveComparer s_ordinal = new OrdinalCaseSensitiveComparer();
         private static readonly OrdinalIgnoreCaseComparer s_ordinalIgnoreCase = new OrdinalIgnoreCaseComparer();        
 
         public static StringComparer InvariantCulture
@@ -170,30 +172,33 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     internal sealed class CultureAwareComparer : StringComparer
     {
-        private readonly CompareInfo _compareInfo;
-        private readonly CompareOptions _options;
+        private readonly CompareInfo _compareInfo; // Do not rename (binary serialization)
+        private readonly bool _ignoreCase; // Do not rename (binary serialization)
 
         internal CultureAwareComparer(CultureInfo culture, bool ignoreCase)
         {
             _compareInfo = culture.CompareInfo;
-            _options = ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None;
+            _ignoreCase = ignoreCase;
         }
 
+        private CompareOptions Options => _ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None;
+
         public override int Compare(string x, string y)
         {
             if (object.ReferenceEquals(x, y)) return 0;
             if (x == null) return -1;
             if (y == null) return 1;
-            return _compareInfo.Compare(x, y, _options);
+            return _compareInfo.Compare(x, y, Options);
         }
 
         public override bool Equals(string x, string y)
         {
             if (object.ReferenceEquals(x, y)) return true;
             if (x == null || y == null) return false;
-            return _compareInfo.Compare(x, y, _options) == 0;
+            return _compareInfo.Compare(x, y, Options) == 0;
         }
 
         public override int GetHashCode(string obj)
@@ -202,7 +207,7 @@ namespace System
             {
                 throw new ArgumentNullException(nameof(obj));
             }
-            return _compareInfo.GetHashCodeOfString(obj, _options);
+            return _compareInfo.GetHashCodeOfString(obj, Options);
         }
 
         // Equals method for the comparer itself.
@@ -211,20 +216,108 @@ namespace System
             CultureAwareComparer comparer = obj as CultureAwareComparer;
             return
                 comparer != null &&
-                _options == comparer._options &&
+                _ignoreCase == comparer._ignoreCase &&
                 _compareInfo.Equals(comparer._compareInfo);
         }
 
         public override int GetHashCode()
         {
             int hashCode = _compareInfo.GetHashCode();
-            return _options == CompareOptions.None ? hashCode : ~hashCode;
+            return _ignoreCase ? ~hashCode : hashCode;
+        }
+    }
+
+    [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
+    internal class OrdinalComparer : StringComparer 
+    {
+        private readonly bool _ignoreCase; // Do not rename (binary serialization)
+
+        internal OrdinalComparer(bool ignoreCase)
+        {
+            _ignoreCase = ignoreCase;
+        }
+
+        public override int Compare(string x, string y)
+        {
+            if (ReferenceEquals(x, y))
+                return 0;
+            if (x == null)
+                return -1;
+            if (y == null)
+                return 1;
+
+            if (_ignoreCase)
+            {
+                return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
+            }
+
+            return string.CompareOrdinal(x, y);
+        }
+
+        public override bool Equals(string x, string y)
+        {
+            if (ReferenceEquals(x, y))
+                return true;
+            if (x == null || y == null)
+                return false;
+
+            if (_ignoreCase)
+            {
+                if (x.Length != y.Length)
+                {
+                    return false;
+                }
+                return (string.Compare(x, y, StringComparison.OrdinalIgnoreCase) == 0);
+            }
+            return x.Equals(y);
+        }
+
+        public override int GetHashCode(string obj)
+        {
+            if (obj == null)
+            {
+#if CORECLR
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
+#else
+                throw new ArgumentNullException(nameof(obj));
+#endif
+            }
+            Contract.EndContractBlock();
+
+            if (_ignoreCase)
+            {
+                return TextInfo.GetHashCodeOrdinalIgnoreCase(obj);
+            }
+
+            return obj.GetHashCode();
+        }
+
+        // Equals method for the comparer itself. 
+        public override bool Equals(object obj)
+        {
+            OrdinalComparer comparer = obj as OrdinalComparer;
+            if (comparer == null)
+            {
+                return false;
+            }
+            return (this._ignoreCase == comparer._ignoreCase);
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = nameof(OrdinalComparer).GetHashCode();
+            return _ignoreCase ? (~hashCode) : hashCode;
         }
     }
 
     [Serializable]
-    internal sealed class OrdinalComparer : StringComparer 
+    internal sealed class OrdinalCaseSensitiveComparer : OrdinalComparer, ISerializable
     {
+        public OrdinalCaseSensitiveComparer() : base(false)
+        {
+        }
+
         public override int Compare(string x, string y) => string.CompareOrdinal(x, y);
 
         public override bool Equals(string x, string y) => string.Equals(x, y);
@@ -242,14 +335,20 @@ namespace System
             return obj.GetHashCode();
         }
 
-        // Equals/GetHashCode methods for the comparer itself. 
-        public override bool Equals(object obj) => obj is OrdinalComparer;
-        public override int GetHashCode() => nameof(OrdinalComparer).GetHashCode();
+        public void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            info.SetType(typeof(OrdinalComparer));
+            info.AddValue("_ignoreCase", false);
+        }
     }
 
-    [Serializable]
-    internal sealed class OrdinalIgnoreCaseComparer : StringComparer
+    [Serializable]    
+    internal sealed class OrdinalIgnoreCaseComparer : OrdinalComparer, ISerializable
     {
+        public OrdinalIgnoreCaseComparer() : base(true)
+        {
+        }
+
         public override int Compare(string x, string y) => string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
 
         public override bool Equals(string x, string y) => string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
@@ -267,8 +366,10 @@ namespace System
             return TextInfo.GetHashCodeOrdinalIgnoreCase(obj);
         }
 
-        // Equals/GetHashCode methods for the comparer itself. 
-        public override bool Equals(object obj) => obj is OrdinalIgnoreCaseComparer;
-        public override int GetHashCode() => nameof(OrdinalIgnoreCaseComparer).GetHashCode();
+        public void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            info.SetType(typeof(OrdinalComparer));
+            info.AddValue("_ignoreCase", true);
+        }
     }
 }
diff --git a/src/mscorlib/shared/System/Text/StringBuilder.cs b/src/mscorlib/shared/System/Text/StringBuilder.cs
index 3a06114bff..1167016cc1 100644
--- a/src/mscorlib/shared/System/Text/StringBuilder.cs
+++ b/src/mscorlib/shared/System/Text/StringBuilder.cs
@@ -35,6 +35,7 @@ namespace System.Text
     // Console.WriteLine(sb2);
     // 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public sealed partial class StringBuilder : ISerializable
     {
         // A StringBuilder is internally represented as a linked list of blocks each of which holds
@@ -58,10 +59,11 @@ namespace System.Text
         //
         //
         internal const int DefaultCapacity = 16;
-        private const String CapacityField = "Capacity";
-        private const String MaxCapacityField = "m_MaxCapacity";
-        private const String StringValueField = "m_StringValue";
-        private const String ThreadIDField = "m_currentThread";
+        private const String CapacityField = "Capacity"; // Do not rename (binary serialization)
+        private const String MaxCapacityField = "m_MaxCapacity"; // Do not rename (binary serialization)
+        private const String StringValueField = "m_StringValue"; // Do not rename (binary serialization)
+        private const String ThreadIDField = "m_currentThread"; // Do not rename (binary serialization)
+
         // We want to keep chunk arrays out of large object heap (< 85K bytes ~ 40K chars) to be sure.
         // Making the maximum chunk size big means less allocation code called, but also more waste
         // in unused characters and slower inserts / replaces (since you do need to slide characters over
diff --git a/src/mscorlib/shared/System/ValueTuple.cs b/src/mscorlib/shared/System/ValueTuple.cs
index e0cd02e914..3464f2781c 100644
--- a/src/mscorlib/shared/System/ValueTuple.cs
+++ b/src/mscorlib/shared/System/ValueTuple.cs
@@ -29,6 +29,7 @@ namespace System
     /// - their members (such as Item1, Item2, etc) are fields rather than properties.
     /// </summary>
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple
         : IEquatable<ValueTuple>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple>, IValueTupleInternal, ITuple
     {
@@ -298,6 +299,7 @@ namespace System
     /// <summary>Represents a 1-tuple, or singleton, as a value type.</summary>
     /// <typeparam name="T1">The type of the tuple's only component.</typeparam>
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1>
         : IEquatable<ValueTuple<T1>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1>>, IValueTupleInternal, ITuple
     {
@@ -464,6 +466,7 @@ namespace System
     /// <typeparam name="T2">The type of the tuple's second component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2>
         : IEquatable<ValueTuple<T1, T2>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2>>, IValueTupleInternal, ITuple
     {
@@ -674,6 +677,7 @@ namespace System
     /// <typeparam name="T3">The type of the tuple's third component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3>
         : IEquatable<ValueTuple<T1, T2, T3>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3>>, IValueTupleInternal, ITuple
     {
@@ -882,6 +886,7 @@ namespace System
     /// <typeparam name="T4">The type of the tuple's fourth component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3, T4>
         : IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IValueTupleInternal, ITuple
     {
@@ -1109,6 +1114,7 @@ namespace System
     /// <typeparam name="T5">The type of the tuple's fifth component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3, T4, T5>
         : IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5>>, IValueTupleInternal, ITuple
     {
@@ -1355,6 +1361,7 @@ namespace System
     /// <typeparam name="T6">The type of the tuple's sixth component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3, T4, T5, T6>
         : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IValueTupleInternal, ITuple
     {
@@ -1620,6 +1627,7 @@ namespace System
     /// <typeparam name="T7">The type of the tuple's seventh component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7>
         : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IValueTupleInternal, ITuple
     {
@@ -1904,6 +1912,7 @@ namespace System
     /// <typeparam name="TRest">The type of the tuple's eighth component.</typeparam>
     [Serializable]
     [StructLayout(LayoutKind.Auto)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]  
     public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>
     : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IValueTupleInternal, ITuple
     where TRest : struct
diff --git a/src/mscorlib/shared/System/Version.cs b/src/mscorlib/shared/System/Version.cs
index 54b2052ddb..a2140ab137 100644
--- a/src/mscorlib/shared/System/Version.cs
+++ b/src/mscorlib/shared/System/Version.cs
@@ -16,14 +16,15 @@ namespace System
     // specified component.
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public sealed class Version : ICloneable, IComparable
         , IComparable<Version>, IEquatable<Version>
     {
         // AssemblyName depends on the order staying the same
-        private readonly int _Major;
-        private readonly int _Minor;
-        private readonly int _Build = -1;
-        private readonly int _Revision = -1;
+        private readonly int _Major; // Do not rename (binary serialization)
+        private readonly int _Minor; // Do not rename (binary serialization)
+        private readonly int _Build = -1; // Do not rename (binary serialization)
+        private readonly int _Revision = -1; // Do not rename (binary serialization)
 
         public Version(int major, int minor, int build, int revision)
         {
diff --git a/src/mscorlib/src/System/AggregateException.cs b/src/mscorlib/src/System/AggregateException.cs
index 22bc323215..0b840972ef 100644
--- a/src/mscorlib/src/System/AggregateException.cs
+++ b/src/mscorlib/src/System/AggregateException.cs
@@ -30,9 +30,10 @@ namespace System
     /// </remarks>
     [Serializable]
     [DebuggerDisplay("Count = {InnerExceptionCount}")]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class AggregateException : Exception
     {
-        private ReadOnlyCollection<Exception> m_innerExceptions; // Complete set of exceptions.
+        private ReadOnlyCollection<Exception> m_innerExceptions; // Complete set of exceptions. Do not rename (binary serialization)
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AggregateException"/> class.
diff --git a/src/mscorlib/src/System/Array.cs b/src/mscorlib/src/System/Array.cs
index fcfeb94675..62a4ecf16e 100644
--- a/src/mscorlib/src/System/Array.cs
+++ b/src/mscorlib/src/System/Array.cs
@@ -26,6 +26,7 @@ namespace System
     // Note that we make a T[] (single-dimensional w/ zero as the lower bound) implement both 
     // IList<U> and IReadOnlyList<U>, where T : U dynamically.  See the SZArrayHelper class for details.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public abstract class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable
     {
         // This ctor exists solely to prevent C# from generating a protected .ctor that violates the surface area. I really want this to be a
diff --git a/src/mscorlib/src/System/ArraySegment.cs b/src/mscorlib/src/System/ArraySegment.cs
index 664352708d..7546c5bd56 100644
--- a/src/mscorlib/src/System/ArraySegment.cs
+++ b/src/mscorlib/src/System/ArraySegment.cs
@@ -26,15 +26,16 @@ namespace System
     // three fields from an ArraySegment may not see the same ArraySegment from one call to another
     // (ie, users could assign a new value to the old location).  
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct ArraySegment<T> : IList<T>, IReadOnlyList<T>
     {
         // Do not replace the array allocation with Array.Empty. We don't want to have the overhead of
         // instantiating another generic type in addition to ArraySegment<T> for new type parameters.
         public static ArraySegment<T> Empty { get; } = new ArraySegment<T>(new T[0]);
 
-        private readonly T[] _array;
-        private readonly int _offset;
-        private readonly int _count;
+        private readonly T[] _array; // Do not rename (binary serialization)
+        private readonly int _offset; // Do not rename (binary serialization)
+        private readonly int _count; // Do not rename (binary serialization)
 
         public ArraySegment(T[] array)
         {
diff --git a/src/mscorlib/src/System/Attribute.cs b/src/mscorlib/src/System/Attribute.cs
index baa9a71638..23fd9aaaaf 100644
--- a/src/mscorlib/src/System/Attribute.cs
+++ b/src/mscorlib/src/System/Attribute.cs
@@ -17,6 +17,7 @@ namespace System
 {
     [Serializable]
     [AttributeUsageAttribute(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public abstract class Attribute
     {
         #region Private Statics
diff --git a/src/mscorlib/src/System/Boolean.cs b/src/mscorlib/src/System/Boolean.cs
index 59cab74456..a1f5064964 100644
--- a/src/mscorlib/src/System/Boolean.cs
+++ b/src/mscorlib/src/System/Boolean.cs
@@ -21,6 +21,7 @@ namespace System
     // The Boolean class provides the
     // object representation of the boolean primitive type.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Boolean : IComparable, IConvertible, IComparable<Boolean>, IEquatable<Boolean>
     {
         //
diff --git a/src/mscorlib/src/System/Byte.cs b/src/mscorlib/src/System/Byte.cs
index da3b790ac6..fafdcbb535 100644
--- a/src/mscorlib/src/System/Byte.cs
+++ b/src/mscorlib/src/System/Byte.cs
@@ -25,6 +25,7 @@ namespace System
     // 
     [Serializable]
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Byte : IComparable, IFormattable, IConvertible
             , IComparable<Byte>, IEquatable<Byte>
     {
diff --git a/src/mscorlib/src/System/Collections/Comparer.cs b/src/mscorlib/src/System/Collections/Comparer.cs
index 76e19e77f1..00259e6bdb 100644
--- a/src/mscorlib/src/System/Collections/Comparer.cs
+++ b/src/mscorlib/src/System/Collections/Comparer.cs
@@ -13,21 +13,17 @@
 ** 
 ===========================================================*/
 
-using System;
 using System.Globalization;
-using System.Runtime.Serialization;
 using System.Diagnostics.Contracts;
 
 namespace System.Collections
 {
-    internal sealed class Comparer : IComparer, ISerializable
+    internal sealed class Comparer : IComparer
     {
         private CompareInfo m_compareInfo;
         public static readonly Comparer Default = new Comparer(CultureInfo.CurrentCulture);
         public static readonly Comparer DefaultInvariant = new Comparer(CultureInfo.InvariantCulture);
 
-        private const String CompareInfoName = "CompareInfo";
-
         private Comparer()
         {
             m_compareInfo = null;
@@ -73,10 +69,5 @@ namespace System.Collections
 
             throw new ArgumentException(SR.Argument_ImplementIComparable);
         }
-
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            throw new PlatformNotSupportedException();
-        }
     }
 }
diff --git a/src/mscorlib/src/System/Collections/Generic/Comparer.cs b/src/mscorlib/src/System/Collections/Generic/Comparer.cs
index e163faa80f..47c241500d 100644
--- a/src/mscorlib/src/System/Collections/Generic/Comparer.cs
+++ b/src/mscorlib/src/System/Collections/Generic/Comparer.cs
@@ -18,6 +18,7 @@ namespace System.Collections.Generic
 {
     [Serializable]
     [TypeDependencyAttribute("System.Collections.Generic.ObjectComparer`1")]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public abstract class Comparer<T> : IComparer, IComparer<T>
     {
         // To minimize generic instantiation overhead of creating the comparer per type, we keep the generic portion of the code as small
@@ -52,6 +53,7 @@ namespace System.Collections.Generic
     // means another generic instantiation, which can be costly esp.
     // for value types.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class GenericComparer<T> : Comparer<T> where T : IComparable<T>
     {
         public override int Compare(T x, T y)
@@ -74,6 +76,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class NullableComparer<T> : Comparer<T?> where T : struct, IComparable<T>
     {
         public override int Compare(T? x, T? y)
@@ -96,6 +99,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class ObjectComparer<T> : Comparer<T>
     {
         public override int Compare(T x, T y)
@@ -132,6 +136,7 @@ namespace System.Collections.Generic
     // since we want to serialize as ObjectComparer for
     // back-compat reasons (see below).
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class Int32EnumComparer<T> : Comparer<T>, ISerializable where T : struct
     {
         public Int32EnumComparer()
@@ -167,6 +172,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class UInt32EnumComparer<T> : Comparer<T>, ISerializable where T : struct
     {
         public UInt32EnumComparer()
@@ -198,6 +204,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class Int64EnumComparer<T> : Comparer<T>, ISerializable where T : struct
     {
         public Int64EnumComparer()
@@ -226,6 +233,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class UInt64EnumComparer<T> : Comparer<T>, ISerializable where T : struct
     {
         public UInt64EnumComparer()
diff --git a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
index cd33428ca1..50724017dd 100644
--- a/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
+++ b/src/mscorlib/src/System/Collections/Generic/Dictionary.cs
@@ -52,6 +52,7 @@ namespace System.Collections.Generic
     [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>, ISerializable, IDeserializationCallback
     {
         private struct Entry
@@ -74,10 +75,10 @@ namespace System.Collections.Generic
         private Object _syncRoot;
 
         // constants for serialization
-        private const String VersionName = "Version";
-        private const String HashSizeName = "HashSize";  // Must save buckets.Length
-        private const String KeyValuePairsName = "KeyValuePairs";
-        private const String ComparerName = "Comparer";
+        private const String VersionName = "Version"; // Do not rename (binary serialization)
+        private const String HashSizeName = "HashSize"; // Do not rename (binary serialization). Must save buckets.Length
+        private const String KeyValuePairsName = "KeyValuePairs"; // Do not rename (binary serialization)
+        private const String ComparerName = "Comparer"; // Do not rename (binary serialization)
 
         public Dictionary() : this(0, null) { }
 
diff --git a/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs b/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
index d6b213c9d7..760c9d10b2 100644
--- a/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
+++ b/src/mscorlib/src/System/Collections/Generic/EqualityComparer.cs
@@ -17,6 +17,7 @@ namespace System.Collections.Generic
 {
     [Serializable]
     [TypeDependencyAttribute("System.Collections.Generic.ObjectEqualityComparer`1")]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public abstract class EqualityComparer<T> : IEqualityComparer, IEqualityComparer<T>
     {
         // To minimize generic instantiation overhead of creating the comparer per type, we keep the generic portion of the code as small
@@ -69,6 +70,7 @@ namespace System.Collections.Generic
     // The methods in this class look identical to the inherited methods, but the calls
     // to Equal bind to IEquatable<T>.Equals(T) instead of Object.Equals(Object)
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal class GenericEqualityComparer<T> : EqualityComparer<T> where T : IEquatable<T>
     {
         [Pure]
@@ -137,6 +139,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class NullableEqualityComparer<T> : EqualityComparer<T?> where T : struct, IEquatable<T>
     {
         [Pure]
@@ -203,6 +206,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class ObjectEqualityComparer<T> : EqualityComparer<T>
     {
         [Pure]
@@ -275,6 +279,7 @@ namespace System.Collections.Generic
     // keep the perofrmance not affected till we hit collision threshold and then we switch to the comparer which is using 
     // randomized string hashing GenericEqualityComparer<string>
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal class NonRandomizedStringEqualityComparer : GenericEqualityComparer<string>
     {
         private static IEqualityComparer<string> s_nonRandomizedComparer;
@@ -302,6 +307,7 @@ namespace System.Collections.Generic
     // Performance of IndexOf on byte array is very important for some scenarios.
     // We will call the C runtime function memchr, which is optimized.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class ByteEqualityComparer : EqualityComparer<byte>
     {
         [Pure]
@@ -353,6 +359,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal class EnumEqualityComparer<T> : EqualityComparer<T>, ISerializable where T : struct
     {
         [Pure]
@@ -416,6 +423,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class SByteEnumEqualityComparer<T> : EnumEqualityComparer<T> where T : struct
     {
         public SByteEnumEqualityComparer() { }
@@ -432,6 +440,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class ShortEnumEqualityComparer<T> : EnumEqualityComparer<T>, ISerializable where T : struct
     {
         public ShortEnumEqualityComparer() { }
@@ -448,6 +457,7 @@ namespace System.Collections.Generic
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal sealed class LongEnumEqualityComparer<T> : EqualityComparer<T>, ISerializable where T : struct
     {
         [Pure]
diff --git a/src/mscorlib/src/System/Collections/Generic/List.cs b/src/mscorlib/src/System/Collections/Generic/List.cs
index 94e794cfd2..2031ddc6ed 100644
--- a/src/mscorlib/src/System/Collections/Generic/List.cs
+++ b/src/mscorlib/src/System/Collections/Generic/List.cs
@@ -30,14 +30,15 @@ namespace System.Collections.Generic
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
     [DebuggerDisplay("Count = {Count}")]
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class List<T> : IList<T>, System.Collections.IList, IReadOnlyList<T>
     {
         private const int _defaultCapacity = 4;
 
-        private T[] _items;
+        private T[] _items; // Do not rename (binary serialization)
         [ContractPublicPropertyName("Count")]
-        private int _size;
-        private int _version;
+        private int _size; // Do not rename (binary serialization)
+        private int _version; // Do not rename (binary serialization)
         [NonSerialized]
         private Object _syncRoot;
 
diff --git a/src/mscorlib/src/System/Collections/ListDictionaryInternal.cs b/src/mscorlib/src/System/Collections/ListDictionaryInternal.cs
index 3f92038d4f..17eb89a2b2 100644
--- a/src/mscorlib/src/System/Collections/ListDictionaryInternal.cs
+++ b/src/mscorlib/src/System/Collections/ListDictionaryInternal.cs
@@ -20,11 +20,12 @@ namespace System.Collections
     ///    will be smaller and faster than a Hashtable if the number of elements is 10 or less.
     ///    This should not be used if performance is important for large numbers of elements.
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     internal class ListDictionaryInternal : IDictionary
     {
-        private DictionaryNode head;
-        private int version;
-        private int count;
+        private DictionaryNode head; // Do not rename (binary serialization)
+        private int version; // Do not rename (binary serialization)
+        private int count; // Do not rename (binary serialization)
         [NonSerialized]
         private Object _syncRoot;
 
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs b/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
index d9801dfaaf..8e5de70e72 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/Collection.cs
@@ -15,9 +15,10 @@ namespace System.Collections.ObjectModel
     [Serializable]
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
     [DebuggerDisplay("Count = {Count}")]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Collection<T> : IList<T>, IList, IReadOnlyList<T>
     {
-        private IList<T> items;
+        private IList<T> items; // Do not rename (binary serialization)
         [NonSerialized]
         private Object _syncRoot;
 
diff --git a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
index b484879c27..03c7d45e16 100644
--- a/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
+++ b/src/mscorlib/src/System/Collections/ObjectModel/ReadOnlyCollection.cs
@@ -15,9 +15,10 @@ namespace System.Collections.ObjectModel
     [Serializable]
     [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
     [DebuggerDisplay("Count = {Count}")]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class ReadOnlyCollection<T> : IList<T>, IList, IReadOnlyList<T>
     {
-        private IList<T> list;
+        private IList<T> list; // Do not rename (binary serialization)
         [NonSerialized]
         private Object _syncRoot;
 
diff --git a/src/mscorlib/src/System/Decimal.cs b/src/mscorlib/src/System/Decimal.cs
index ce59a99334..b120a368da 100644
--- a/src/mscorlib/src/System/Decimal.cs
+++ b/src/mscorlib/src/System/Decimal.cs
@@ -59,6 +59,7 @@ namespace System
     [StructLayout(LayoutKind.Sequential)]
     [Serializable]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Decimal : IFormattable, IComparable, IConvertible, IComparable<Decimal>, IEquatable<Decimal>, IDeserializationCallback
     {
         // Sign mask for the flags field. A value of zero in this bit indicates a
@@ -132,7 +133,8 @@ namespace System
         // positive and 1 meaning negative.
         //
         // NOTE: Do not change the order in which these fields are declared. The
-        // native methods in this class rely on this particular order.
+        // native methods in this class rely on this particular order. 
+        // Do not rename (binary serialization).
         private int flags;
         private int hi;
         private int lo;
diff --git a/src/mscorlib/src/System/Double.cs b/src/mscorlib/src/System/Double.cs
index 30fa1a58b3..b64bb72ed2 100644
--- a/src/mscorlib/src/System/Double.cs
+++ b/src/mscorlib/src/System/Double.cs
@@ -23,6 +23,7 @@ namespace System
 {
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Double : IComparable, IFormattable, IConvertible
             , IComparable<Double>, IEquatable<Double>
     {
diff --git a/src/mscorlib/src/System/Enum.cs b/src/mscorlib/src/System/Enum.cs
index 489f36739c..25a4ff34d3 100644
--- a/src/mscorlib/src/System/Enum.cs
+++ b/src/mscorlib/src/System/Enum.cs
@@ -15,6 +15,7 @@ using System.Diagnostics.Contracts;
 namespace System
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
     {
         #region Private Constants
diff --git a/src/mscorlib/src/System/Exception.cs b/src/mscorlib/src/System/Exception.cs
index 8d01b4c461..725adac4a9 100644
--- a/src/mscorlib/src/System/Exception.cs
+++ b/src/mscorlib/src/System/Exception.cs
@@ -28,6 +28,7 @@ namespace System
     using System.Diagnostics.Contracts;
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Exception : ISerializable
     {
         private void Init()
@@ -75,17 +76,17 @@ namespace System
                 throw new ArgumentNullException(nameof(info));
             Contract.EndContractBlock();
 
-            _className = info.GetString("ClassName");
-            _message = info.GetString("Message");
-            _data = (IDictionary)(info.GetValueNoThrow("Data", typeof(IDictionary)));
-            _innerException = (Exception)(info.GetValue("InnerException", typeof(Exception)));
-            _helpURL = info.GetString("HelpURL");
-            _stackTraceString = info.GetString("StackTraceString");
-            _remoteStackTraceString = info.GetString("RemoteStackTraceString");
-            _remoteStackIndex = info.GetInt32("RemoteStackIndex");
-            
-            HResult = info.GetInt32("HResult");
-            _source = info.GetString("Source");
+            _className = info.GetString("ClassName"); // Do not rename (binary serialization)
+            _message = info.GetString("Message"); // Do not rename (binary serialization)
+            _data = (IDictionary)(info.GetValueNoThrow("Data", typeof(IDictionary))); // Do not rename (binary serialization)
+            _innerException = (Exception)(info.GetValue("InnerException", typeof(Exception))); // Do not rename (binary serialization)
+            _helpURL = info.GetString("HelpURL"); // Do not rename (binary serialization)
+            _stackTraceString = info.GetString("StackTraceString"); // Do not rename (binary serialization)
+            _remoteStackTraceString = info.GetString("RemoteStackTraceString"); // Do not rename (binary serialization)
+            _remoteStackIndex = info.GetInt32("RemoteStackIndex"); // Do not rename (binary serialization)
+
+            HResult = info.GetInt32("HResult"); // Do not rename (binary serialization)
+            _source = info.GetString("Source"); // Do not rename (binary serialization)
 
             // Get the WatsonBuckets that were serialized - this is particularly
             // done to support exceptions going across AD transitions.
@@ -93,7 +94,7 @@ namespace System
             // We use the no throw version since we could be deserializing a pre-V4
             // exception object that may not have this entry. In such a case, we would
             // get null.
-            _watsonBuckets = (Object)info.GetValueNoThrow("WatsonBuckets", typeof(byte[]));
+            _watsonBuckets = (Object)info.GetValueNoThrow("WatsonBuckets", typeof(byte[])); // Do not rename (binary serialization)
 
 
             if (_className == null || HResult == 0)
@@ -459,20 +460,20 @@ namespace System
                 _source = Source; // Set the Source information correctly before serialization
             }
 
-            info.AddValue("ClassName", GetClassName(), typeof(String));
-            info.AddValue("Message", _message, typeof(String));
-            info.AddValue("Data", _data, typeof(IDictionary));
-            info.AddValue("InnerException", _innerException, typeof(Exception));
-            info.AddValue("HelpURL", _helpURL, typeof(String));
-            info.AddValue("StackTraceString", tempStackTraceString, typeof(String));
-            info.AddValue("RemoteStackTraceString", _remoteStackTraceString, typeof(String));
-            info.AddValue("RemoteStackIndex", _remoteStackIndex, typeof(Int32));
-            info.AddValue("ExceptionMethod", null, typeof(String));
-            info.AddValue("HResult", HResult);
-            info.AddValue("Source", _source, typeof(String));
+            info.AddValue("ClassName", GetClassName(), typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("Message", _message, typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("Data", _data, typeof(IDictionary)); // Do not rename (binary serialization)
+            info.AddValue("InnerException", _innerException, typeof(Exception)); // Do not rename (binary serialization)
+            info.AddValue("HelpURL", _helpURL, typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("StackTraceString", tempStackTraceString, typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("RemoteStackTraceString", _remoteStackTraceString, typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("RemoteStackIndex", _remoteStackIndex, typeof(Int32)); // Do not rename (binary serialization)
+            info.AddValue("ExceptionMethod", null, typeof(String)); // Do not rename (binary serialization)
+            info.AddValue("HResult", HResult); // Do not rename (binary serialization)
+            info.AddValue("Source", _source, typeof(String)); // Do not rename (binary serialization)
 
             // Serialize the Watson bucket details as well
-            info.AddValue("WatsonBuckets", _watsonBuckets, typeof(byte[]));
+            info.AddValue("WatsonBuckets", _watsonBuckets, typeof(byte[])); // Do not rename (binary serialization)
         }
 
         // This method will clear the _stackTrace of the exception object upon deserialization
diff --git a/src/mscorlib/src/System/Globalization/CompareInfo.Windows.cs b/src/mscorlib/src/System/Globalization/CompareInfo.Windows.cs
index eb4dc5613e..0df5463a2f 100644
--- a/src/mscorlib/src/System/Globalization/CompareInfo.Windows.cs
+++ b/src/mscorlib/src/System/Globalization/CompareInfo.Windows.cs
@@ -469,6 +469,7 @@ namespace System.Globalization
             Debug.Assert(!_invariantMode);
 
             Interop.Kernel32.NlsVersionInfoEx nlsVersion = new Interop.Kernel32.NlsVersionInfoEx();
+            nlsVersion.dwNLSVersionInfoSize = Marshal.SizeOf(typeof(Interop.Kernel32.NlsVersionInfoEx));
             Interop.Kernel32.GetNLSVersionEx(Interop.Kernel32.COMPARE_STRING, _sortName, &nlsVersion);
             return new SortVersion(
                         nlsVersion.dwNLSVersion,
diff --git a/src/mscorlib/src/System/Globalization/CompareInfo.cs b/src/mscorlib/src/System/Globalization/CompareInfo.cs
index 593e86415d..bfdbdc546b 100644
--- a/src/mscorlib/src/System/Globalization/CompareInfo.cs
+++ b/src/mscorlib/src/System/Globalization/CompareInfo.cs
@@ -34,6 +34,7 @@ namespace System.Globalization
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public partial class CompareInfo : IDeserializationCallback
     {
         // Mask used to check if IndexOf()/LastIndexOf()/IsPrefix()/IsPostfix() has the right flags.
@@ -69,11 +70,13 @@ namespace System.Globalization
         private string _sortName; // The name that defines our behavior.
 
         [OptionalField(VersionAdded = 3)]
-        private SortVersion m_sortVersion; // Do not rename (binary serialization)
+        private SortVersion m_SortVersion; // Do not rename (binary serialization)
 
         // _invariantMode is defined for the perf reason as accessing the instance field is faster than access the static property GlobalizationMode.Invariant
         [NonSerialized]
         private readonly bool _invariantMode = GlobalizationMode.Invariant;
+        
+        private int culture; // Do not rename (binary serialization). The fields sole purpose is to support Desktop serialization.
 
         internal CompareInfo(CultureInfo culture)
         {
@@ -233,14 +236,26 @@ namespace System.Globalization
 
         private void OnDeserialized()
         {
-            if (m_name != null)
+            // If we didn't have a name, use the LCID
+            if (m_name == null)
+            {
+                // From whidbey, didn't have a name
+                CultureInfo ci = CultureInfo.GetCultureInfo(this.culture);
+                m_name = ci._name;
+            }
+            else
             {
                 InitSort(CultureInfo.GetCultureInfo(m_name));
             }
         }
 
         [OnSerializing]
-        private void OnSerializing(StreamingContext ctx) { }
+        private void OnSerializing(StreamingContext ctx)
+        {
+            // This is merely for serialization compatibility with Whidbey/Orcas, it can go away when we don't want that compat any more.
+            culture = CultureInfo.GetCultureInfo(this.Name).LCID; // This is the lcid of the constructing culture (still have to dereference to get target sort)
+            Contract.Assert(m_name != null, "CompareInfo.OnSerializing - expected m_name to be set already");
+        }
 
         ///////////////////////////----- Name -----/////////////////////////////////
         //
@@ -1208,11 +1223,11 @@ namespace System.Globalization
         {
             get
             {
-                if (m_sortVersion == null)
+                if (m_SortVersion == null)
                 {
                     if (_invariantMode)
                     {
-                        m_sortVersion = new SortVersion(0, CultureInfo.LOCALE_INVARIANT, new Guid(0, 0, 0, 0, 0, 0, 0,
+                        m_SortVersion = new SortVersion(0, CultureInfo.LOCALE_INVARIANT, new Guid(0, 0, 0, 0, 0, 0, 0,
                                                                         (byte) (CultureInfo.LOCALE_INVARIANT >> 24),
                                                                         (byte) ((CultureInfo.LOCALE_INVARIANT  & 0x00FF0000) >> 16),
                                                                         (byte) ((CultureInfo.LOCALE_INVARIANT  & 0x0000FF00) >> 8),
@@ -1220,11 +1235,11 @@ namespace System.Globalization
                     }
                     else
                     {
-                        m_sortVersion = GetSortVersion();
+                        m_SortVersion = GetSortVersion();
                     }
                 }
 
-                return m_sortVersion;
+                return m_SortVersion;
             }
         }
 
diff --git a/src/mscorlib/src/System/Globalization/CultureInfo.cs b/src/mscorlib/src/System/Globalization/CultureInfo.cs
index 16e2d291a1..ee64bc52e2 100644
--- a/src/mscorlib/src/System/Globalization/CultureInfo.cs
+++ b/src/mscorlib/src/System/Globalization/CultureInfo.cs
@@ -206,6 +206,26 @@ namespace System.Globalization
             InitializeFromName(name, useUserOverride);
         }
 
+        private CultureInfo(CultureData cultureData)
+        {
+            Debug.Assert(cultureData != null);
+            _cultureData = cultureData;
+            _name = cultureData.CultureName;
+            _isInherited = false;
+        }
+
+        private static CultureInfo CreateCultureInfoNoThrow(string name, bool useUserOverride)
+        {
+            Debug.Assert(name != null);
+            CultureData cultureData = CultureData.GetCultureData(name, useUserOverride);
+            if (cultureData == null)
+            {
+                return null;
+            }
+
+            return new CultureInfo(cultureData);
+        }        
+
         public CultureInfo(int culture) : this(culture, true) 
         {
         }
@@ -533,25 +553,22 @@ namespace System.Globalization
             {
                 if (null == _parent)
                 {
-                    try
-                    {
-                        string parentName = _cultureData.SPARENT;
+                    string parentName = _cultureData.SPARENT;
 
-                        if (String.IsNullOrEmpty(parentName))
+                    if (String.IsNullOrEmpty(parentName))
+                    {
+                        _parent = InvariantCulture;
+                    }
+                    else
+                    {
+                        _parent = CreateCultureInfoNoThrow(parentName, _cultureData.UseUserOverride);
+                        if (_parent == null)
                         {
+                            // For whatever reason our IPARENT or SPARENT wasn't correct, so use invariant
+                            // We can't allow ourselves to fail.  In case of custom cultures the parent of the
+                            // current custom culture isn't installed.
                             _parent = InvariantCulture;
                         }
-                        else
-                        {
-                            _parent = new CultureInfo(parentName, _cultureData.UseUserOverride);
-                        }
-                    }
-                    catch (ArgumentException)
-                    {
-                        // For whatever reason our IPARENT or SPARENT wasn't correct, so use invariant
-                        // We can't allow ourselves to fail.  In case of custom cultures the parent of the
-                        // current custom culture isn't installed.
-                        _parent = InvariantCulture;
                     }
                 }
                 return _parent;
diff --git a/src/mscorlib/src/System/Guid.cs b/src/mscorlib/src/System/Guid.cs
index f64211d5d0..e3b3a6f944 100644
--- a/src/mscorlib/src/System/Guid.cs
+++ b/src/mscorlib/src/System/Guid.cs
@@ -18,6 +18,7 @@ namespace System
     [StructLayout(LayoutKind.Sequential)]
     [Serializable]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Guid : IFormattable, IComparable
         , IComparable<Guid>, IEquatable<Guid>
     {
@@ -25,17 +26,17 @@ namespace System
         ////////////////////////////////////////////////////////////////////////////////
         //  Member variables
         ////////////////////////////////////////////////////////////////////////////////
-        private int _a;
-        private short _b;
-        private short _c;
-        private byte _d;
-        private byte _e;
-        private byte _f;
-        private byte _g;
-        private byte _h;
-        private byte _i;
-        private byte _j;
-        private byte _k;
+        private int _a; // Do not rename (binary serialization)
+        private short _b; // Do not rename (binary serialization)
+        private short _c; // Do not rename (binary serialization)
+        private byte _d; // Do not rename (binary serialization)
+        private byte _e; // Do not rename (binary serialization)
+        private byte _f; // Do not rename (binary serialization)
+        private byte _g; // Do not rename (binary serialization)
+        private byte _h; // Do not rename (binary serialization)
+        private byte _i; // Do not rename (binary serialization)
+        private byte _j; // Do not rename (binary serialization)
+        private byte _k; // Do not rename (binary serialization)
 
 
 
diff --git a/src/mscorlib/src/System/Int16.cs b/src/mscorlib/src/System/Int16.cs
index aced05df6d..82e5dd5a38 100644
--- a/src/mscorlib/src/System/Int16.cs
+++ b/src/mscorlib/src/System/Int16.cs
@@ -22,6 +22,7 @@ namespace System
 {
     [Serializable]
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Int16 : IComparable, IFormattable, IConvertible
             , IComparable<Int16>, IEquatable<Int16>
     {
diff --git a/src/mscorlib/src/System/Int32.cs b/src/mscorlib/src/System/Int32.cs
index afee0e42d7..503552117d 100644
--- a/src/mscorlib/src/System/Int32.cs
+++ b/src/mscorlib/src/System/Int32.cs
@@ -22,6 +22,7 @@ namespace System
 {
     [Serializable]
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Int32 : IComparable, IFormattable, IConvertible
             , IComparable<Int32>, IEquatable<Int32>
     {
diff --git a/src/mscorlib/src/System/Int64.cs b/src/mscorlib/src/System/Int64.cs
index 619bf7e5d7..015387233c 100644
--- a/src/mscorlib/src/System/Int64.cs
+++ b/src/mscorlib/src/System/Int64.cs
@@ -21,6 +21,7 @@ namespace System
 {
     [Serializable]
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Int64 : IComparable, IFormattable, IConvertible
             , IComparable<Int64>, IEquatable<Int64>
     {
diff --git a/src/mscorlib/src/System/IntPtr.cs b/src/mscorlib/src/System/IntPtr.cs
index 55c86e3795..e3439801ff 100644
--- a/src/mscorlib/src/System/IntPtr.cs
+++ b/src/mscorlib/src/System/IntPtr.cs
@@ -23,9 +23,10 @@ namespace System
     using System.Diagnostics.Contracts;
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct IntPtr : IEquatable<IntPtr>, ISerializable
     {
-        unsafe private void* _value; // The compiler treats void* closest to uint hence explicit casts are required to preserve int behavior
+        unsafe private void* _value; // The compiler treats void* closest to uint hence explicit casts are required to preserve int behavior. Do not rename (binary serialization)
 
         public static readonly IntPtr Zero;
 
diff --git a/src/mscorlib/src/System/Nullable.cs b/src/mscorlib/src/System/Nullable.cs
index 31a62ecea8..a2c7c350c9 100644
--- a/src/mscorlib/src/System/Nullable.cs
+++ b/src/mscorlib/src/System/Nullable.cs
@@ -23,10 +23,11 @@ namespace System
     // 
     [Serializable]
     [System.Runtime.Versioning.NonVersionable] // This only applies to field layout
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Nullable<T> where T : struct
     {
-        private bool hasValue;
-        internal T value;
+        private bool hasValue; // Do not rename (binary serialization)
+        internal T value; // Do not rename (binary serialization)
 
         [System.Runtime.Versioning.NonVersionable]
         public Nullable(T value)
diff --git a/src/mscorlib/src/System/Object.cs b/src/mscorlib/src/System/Object.cs
index a476557911..8df1caa9e5 100644
--- a/src/mscorlib/src/System/Object.cs
+++ b/src/mscorlib/src/System/Object.cs
@@ -34,6 +34,7 @@ namespace System
     [Serializable]
     [ClassInterface(ClassInterfaceType.AutoDual)]
     [System.Runtime.InteropServices.ComVisible(true)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Object
     {
         // Creates a new instance of an Object.
diff --git a/src/mscorlib/src/System/Reflection/Assembly.CoreCLR.cs b/src/mscorlib/src/System/Reflection/Assembly.CoreCLR.cs
index 9d34b48177..49a55181d4 100644
--- a/src/mscorlib/src/System/Reflection/Assembly.CoreCLR.cs
+++ b/src/mscorlib/src/System/Reflection/Assembly.CoreCLR.cs
@@ -52,7 +52,19 @@ namespace System.Reflection
             string requestedAssemblyPath = Path.Combine(Path.GetDirectoryName(requestorPath), requestedAssemblyName.Name+".dll");
 
             // Load the dependency via LoadFrom so that it goes through the same path of being in the LoadFrom list.
-            return Assembly.LoadFrom(requestedAssemblyPath);
+            Assembly resolvedAssembly = null;
+
+            try
+            {
+                resolvedAssembly = Assembly.LoadFrom(requestedAssemblyPath);
+            }
+            catch(FileNotFoundException)
+            {
+                // Catch FileNotFoundException when attempting to resolve assemblies via this handler to account for missing assemblies.
+                resolvedAssembly = null;
+            }
+
+            return resolvedAssembly;
         }
 
         public static Assembly LoadFrom(String assemblyFile)
diff --git a/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs b/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs
deleted file mode 100644
index 3179df09b7..0000000000
--- a/src/mscorlib/src/System/Resources/LooselyLinkedResourceReference.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-/*============================================================
-**
-** 
-** 
-**
-**
-** Purpose: Provides a localizable way of retrieving a file
-** that is linked into your assembly and/or satellite assembly
-** while also leaving the file on disk for unmanaged tools.
-**
-** 
-===========================================================*/
-
-// Removing LooselyLinkedResourceReference from Whidbey.  We don't
-// yet have any strong customer need for it yet.
-#if LOOSELY_LINKED_RESOURCE_REFERENCE
-
-namespace System.Resources {
-    using System.Reflection;
-    using System.Diagnostics.Contracts;
-    using System.IO;
-    using System.Runtime.InteropServices;
-    using System.Globalization;
-
-    [Serializable]
-
-    public struct LooselyLinkedResourceReference {
-        private String _manifestResourceName;
-        private String _typeName;
-
-        public LooselyLinkedResourceReference(String looselyLinkedResourceName, String typeName)
-        {
-            if (looselyLinkedResourceName == null)
-                throw new ArgumentNullException(nameof(looselyLinkedResourceName));
-            if (typeName == null)
-                throw new ArgumentNullException(nameof(typeName));
-            if (looselyLinkedResourceName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(looselyLinkedResourceName));
-            if (typeName.Length == 0)
-                throw new ArgumentException(SR.Argument_EmptyName, nameof(typeName));
-            Contract.EndContractBlock();
-            
-            _manifestResourceName = looselyLinkedResourceName;
-            _typeName = typeName;
-        }
-
-        public String LooselyLinkedResourceName { 
-            get { return _manifestResourceName; }
-        }
-
-        public String TypeName {
-            get { return _typeName; }
-        }
-
-        public Object Resolve(Assembly assembly)
-        {
-            if (assembly == null)
-                throw new ArgumentNullException(nameof(assembly));
-            Contract.EndContractBlock();
-
-            Stream data = assembly.GetManifestResourceStream(_manifestResourceName);
-            if (data == null)
-                throw new MissingManifestResourceException(SR.Format(SR.MissingManifestResource_LooselyLinked, _manifestResourceName, assembly.FullName));
-
-            Type type = Type.GetType(_typeName, true);
-            
-            Object obj = Activator.CreateInstance(type, new Object[] { data });
-            return obj;
-        }
-
-        // For good debugging with tools like ResView
-        public override String ToString()
-        {
-            // This is for debugging only.  Since we use the property names,
-            // this does not need to be localized.
-            return "LooselyLinkedResourceName = \""+ _manifestResourceName +"\", TypeName = \"" + _typeName + "\"";
-        }
-    }
-}
-
-#endif // LOOSELY_LINKED_RESOURCE_REFERENCE
diff --git a/src/mscorlib/src/System/SByte.cs b/src/mscorlib/src/System/SByte.cs
index 9e550936fe..8a0ab3e129 100644
--- a/src/mscorlib/src/System/SByte.cs
+++ b/src/mscorlib/src/System/SByte.cs
@@ -21,6 +21,7 @@ namespace System
     // A place holder class for signed bytes.
     [Serializable]
     [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct SByte : IComparable, IFormattable, IConvertible
         , IComparable<SByte>, IEquatable<SByte>
     {
diff --git a/src/mscorlib/src/System/Single.cs b/src/mscorlib/src/System/Single.cs
index 24e6839be6..c94e673c26 100644
--- a/src/mscorlib/src/System/Single.cs
+++ b/src/mscorlib/src/System/Single.cs
@@ -22,6 +22,7 @@ namespace System
 {
     [Serializable]
     [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public struct Single : IComparable, IFormattable, IConvertible
             , IComparable<Single>, IEquatable<Single>
     {
diff --git a/src/mscorlib/src/System/String.cs b/src/mscorlib/src/System/String.cs
index 0a17c1ee24..c2b7466d92 100644
--- a/src/mscorlib/src/System/String.cs
+++ b/src/mscorlib/src/System/String.cs
@@ -40,6 +40,7 @@ namespace System
     // (indices) are zero-based.
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public sealed partial class String : IComparable, ICloneable, IConvertible, IEnumerable
         , IComparable<String>, IEnumerable<char>, IEquatable<String>
     {
diff --git a/src/mscorlib/src/System/TimeSpan.cs b/src/mscorlib/src/System/TimeSpan.cs
index 9166656d0f..ca60bcb16f 100644
--- a/src/mscorlib/src/System/TimeSpan.cs
+++ b/src/mscorlib/src/System/TimeSpan.cs
@@ -68,7 +68,7 @@ namespace System
 
         // internal so that DateTime doesn't have to call an extra get
         // method for some arithmetic operations.
-        internal long _ticks;
+        internal long _ticks; // Do not rename (binary serialization)
 
         //public TimeSpan() {
         //    _ticks = 0;
diff --git a/src/mscorlib/src/System/TimeZoneInfo.AdjustmentRule.cs b/src/mscorlib/src/System/TimeZoneInfo.AdjustmentRule.cs
index c0c27eeab7..79fe8db815 100644
--- a/src/mscorlib/src/System/TimeZoneInfo.AdjustmentRule.cs
+++ b/src/mscorlib/src/System/TimeZoneInfo.AdjustmentRule.cs
@@ -212,13 +212,13 @@ namespace System
                 }
                 Contract.EndContractBlock();
 
-                info.AddValue("DateStart", _dateStart);
-                info.AddValue("DateEnd", _dateEnd);
-                info.AddValue("DaylightDelta", _daylightDelta);
-                info.AddValue("DaylightTransitionStart", _daylightTransitionStart);
-                info.AddValue("DaylightTransitionEnd", _daylightTransitionEnd);
-                info.AddValue("BaseUtcOffsetDelta", _baseUtcOffsetDelta);
-                info.AddValue("NoDaylightTransitions", _noDaylightTransitions);
+                info.AddValue("DateStart", _dateStart); // Do not rename (binary serialization)
+                info.AddValue("DateEnd", _dateEnd); // Do not rename (binary serialization)
+                info.AddValue("DaylightDelta", _daylightDelta); // Do not rename (binary serialization)
+                info.AddValue("DaylightTransitionStart", _daylightTransitionStart); // Do not rename (binary serialization)
+                info.AddValue("DaylightTransitionEnd", _daylightTransitionEnd); // Do not rename (binary serialization)
+                info.AddValue("BaseUtcOffsetDelta", _baseUtcOffsetDelta); // Do not rename (binary serialization)
+                info.AddValue("NoDaylightTransitions", _noDaylightTransitions); // Do not rename (binary serialization)
             }
 
             private AdjustmentRule(SerializationInfo info, StreamingContext context)
@@ -228,19 +228,19 @@ namespace System
                     throw new ArgumentNullException(nameof(info));
                 }
 
-                _dateStart = (DateTime)info.GetValue("DateStart", typeof(DateTime));
-                _dateEnd = (DateTime)info.GetValue("DateEnd", typeof(DateTime));
-                _daylightDelta = (TimeSpan)info.GetValue("DaylightDelta", typeof(TimeSpan));
-                _daylightTransitionStart = (TransitionTime)info.GetValue("DaylightTransitionStart", typeof(TransitionTime));
-                _daylightTransitionEnd = (TransitionTime)info.GetValue("DaylightTransitionEnd", typeof(TransitionTime));
+                _dateStart = (DateTime)info.GetValue("DateStart", typeof(DateTime)); // Do not rename (binary serialization)
+                _dateEnd = (DateTime)info.GetValue("DateEnd", typeof(DateTime)); // Do not rename (binary serialization)
+                _daylightDelta = (TimeSpan)info.GetValue("DaylightDelta", typeof(TimeSpan)); // Do not rename (binary serialization)
+                _daylightTransitionStart = (TransitionTime)info.GetValue("DaylightTransitionStart", typeof(TransitionTime)); // Do not rename (binary serialization)
+                _daylightTransitionEnd = (TransitionTime)info.GetValue("DaylightTransitionEnd", typeof(TransitionTime)); // Do not rename (binary serialization)
 
-                object o = info.GetValueNoThrow("BaseUtcOffsetDelta", typeof(TimeSpan));
+                object o = info.GetValueNoThrow("BaseUtcOffsetDelta", typeof(TimeSpan)); // Do not rename (binary serialization)
                 if (o != null)
                 {
                     _baseUtcOffsetDelta = (TimeSpan)o;
                 }
 
-                o = info.GetValueNoThrow("NoDaylightTransitions", typeof(bool));
+                o = info.GetValueNoThrow("NoDaylightTransitions", typeof(bool)); // Do not rename (binary serialization)
                 if (o != null)
                 {
                     _noDaylightTransitions = (bool)o;
diff --git a/src/mscorlib/src/System/TimeZoneInfo.TransitionTime.cs b/src/mscorlib/src/System/TimeZoneInfo.TransitionTime.cs
index 1e1d9d328b..0fe3dab0b6 100644
--- a/src/mscorlib/src/System/TimeZoneInfo.TransitionTime.cs
+++ b/src/mscorlib/src/System/TimeZoneInfo.TransitionTime.cs
@@ -132,12 +132,12 @@ namespace System
                 }
                 Contract.EndContractBlock();
 
-                info.AddValue("TimeOfDay", _timeOfDay);
-                info.AddValue("Month", _month);
-                info.AddValue("Week", _week);
-                info.AddValue("Day", _day);
-                info.AddValue("DayOfWeek", _dayOfWeek);
-                info.AddValue("IsFixedDateRule", _isFixedDateRule);
+                info.AddValue("TimeOfDay", _timeOfDay); // Do not rename (binary serialization)
+                info.AddValue("Month", _month); // Do not rename (binary serialization)
+                info.AddValue("Week", _week); // Do not rename (binary serialization)
+                info.AddValue("Day", _day); // Do not rename (binary serialization)
+                info.AddValue("DayOfWeek", _dayOfWeek); // Do not rename (binary serialization)
+                info.AddValue("IsFixedDateRule", _isFixedDateRule); // Do not rename (binary serialization)
             }
 
             private TransitionTime(SerializationInfo info, StreamingContext context)
@@ -147,12 +147,12 @@ namespace System
                     throw new ArgumentNullException(nameof(info));
                 }
 
-                _timeOfDay = (DateTime)info.GetValue("TimeOfDay", typeof(DateTime));
-                _month = (byte)info.GetValue("Month", typeof(byte));
-                _week = (byte)info.GetValue("Week", typeof(byte));
-                _day = (byte)info.GetValue("Day", typeof(byte));
-                _dayOfWeek = (DayOfWeek)info.GetValue("DayOfWeek", typeof(DayOfWeek));
-                _isFixedDateRule = (bool)info.GetValue("IsFixedDateRule", typeof(bool));
+                _timeOfDay = (DateTime)info.GetValue("TimeOfDay", typeof(DateTime)); // Do not rename (binary serialization)
+                _month = (byte)info.GetValue("Month", typeof(byte)); // Do not rename (binary serialization)
+                _week = (byte)info.GetValue("Week", typeof(byte)); // Do not rename (binary serialization)
+                _day = (byte)info.GetValue("Day", typeof(byte)); // Do not rename (binary serialization)
+                _dayOfWeek = (DayOfWeek)info.GetValue("DayOfWeek", typeof(DayOfWeek)); // Do not rename (binary serialization)
+                _isFixedDateRule = (bool)info.GetValue("IsFixedDateRule", typeof(bool)); // Do not rename (binary serialization)
             }
         }
     }
diff --git a/src/mscorlib/src/System/TimeZoneInfo.cs b/src/mscorlib/src/System/TimeZoneInfo.cs
index 8ed7e229c0..a492275a71 100644
--- a/src/mscorlib/src/System/TimeZoneInfo.cs
+++ b/src/mscorlib/src/System/TimeZoneInfo.cs
@@ -29,6 +29,7 @@ namespace System
     };
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
     public sealed partial class TimeZoneInfo : IEquatable<TimeZoneInfo>, ISerializable, IDeserializationCallback
     {
         private enum TimeZoneInfoResult
@@ -1040,13 +1041,13 @@ namespace System
             }
             Contract.EndContractBlock();
 
-            info.AddValue("Id", _id);
-            info.AddValue("DisplayName", _displayName);
-            info.AddValue("StandardName", _standardDisplayName);
-            info.AddValue("DaylightName", _daylightDisplayName);
-            info.AddValue("BaseUtcOffset", _baseUtcOffset);
-            info.AddValue("AdjustmentRules", _adjustmentRules);
-            info.AddValue("SupportsDaylightSavingTime", _supportsDaylightSavingTime);
+            info.AddValue("Id", _id); // Do not rename (binary serialization)
+            info.AddValue("DisplayName", _displayName); // Do not rename (binary serialization)
+            info.AddValue("StandardName", _standardDisplayName); // Do not rename (binary serialization)
+            info.AddValue("DaylightName", _daylightDisplayName); // Do not rename (binary serialization)
+            info.AddValue("BaseUtcOffset", _baseUtcOffset); // Do not rename (binary serialization)
+            info.AddValue("AdjustmentRules", _adjustmentRules); // Do not rename (binary serialization)
+            info.AddValue("SupportsDaylightSavingTime", _supportsDaylightSavingTime); // Do not rename (binary serialization)
         }
 
         private TimeZoneInfo(SerializationInfo info, StreamingContext context)
@@ -1056,13 +1057,13 @@ namespace System
                 throw new ArgumentNullException(nameof(info));
             }
 
-            _id = (string)info.GetValue("Id", typeof(string));
-            _displayName = (string)info.GetValue("DisplayName", typeof(string));
-            _standardDisplayName = (string)info.GetValue("StandardName", typeof(string));
-            _daylightDisplayName = (string)info.GetValue("DaylightName", typeof(string));
-            _baseUtcOffset = (TimeSpan)info.GetValue("BaseUtcOffset", typeof(TimeSpan));
-            _adjustmentRules = (AdjustmentRule[])info.GetValue("AdjustmentRules", typeof(AdjustmentRule[]));
-            _supportsDaylightSavingTime = (bool)info.GetValue("SupportsDaylightSavingTime", typeof(bool));
+            _id = (string)info.GetValue("Id", typeof(string)); // Do not rename (binary serialization)
+            _displayName = (string)info.GetValue("DisplayName", typeof(string)); // Do not rename (binary serialization)
+            _standardDisplayName = (string)info.GetValue("StandardName", typeof(string)); // Do not rename (binary serialization)
+            _daylightDisplayName = (string)info.GetValue("DaylightName", typeof(string)); // Do not rename (binary serialization)
+            _baseUtcOffset = (TimeSpan)info.GetValue("BaseUtcOffset", typeof(TimeSpan)); // Do not rename (binary serialization)
+            _adjustmentRules = (AdjustmentRule[])info.GetValue("AdjustmentRules", typeof(AdjustmentRule[])); // Do not rename (binary serialization)
+            _supportsDaylightSavingTime = (bool)info.GetValue("SupportsDaylightSavingTime", typeof(bool)); // Do not rename (binary serialization)
         }
 
         private AdjustmentRule GetAdjustmentRuleForTime(DateTime dateTime, out int? ruleIndex)
diff --git a/src/mscorlib/src/System/Tuple.cs b/src/mscorlib/src/System/Tuple.cs
index a118df02bd..6a8758278c 100644
--- a/src/mscorlib/src/System/Tuple.cs
+++ b/src/mscorlib/src/System/Tuple.cs
@@ -105,9 +105,10 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
 
@@ -204,10 +205,11 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -318,11 +320,12 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -443,12 +446,13 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
-        private readonly T4 m_Item4;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
+        private readonly T4 m_Item4; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -579,13 +583,14 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
-        private readonly T4 m_Item4;
-        private readonly T5 m_Item5;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
+        private readonly T4 m_Item4; // Do not rename (binary serialization)
+        private readonly T5 m_Item5; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -726,14 +731,15 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
-        private readonly T4 m_Item4;
-        private readonly T5 m_Item5;
-        private readonly T6 m_Item6;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
+        private readonly T4 m_Item4; // Do not rename (binary serialization)
+        private readonly T5 m_Item5; // Do not rename (binary serialization)
+        private readonly T6 m_Item6; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -884,15 +890,16 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
-        private readonly T4 m_Item4;
-        private readonly T5 m_Item5;
-        private readonly T6 m_Item6;
-        private readonly T7 m_Item7;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
+        private readonly T4 m_Item4; // Do not rename (binary serialization)
+        private readonly T5 m_Item5; // Do not rename (binary serialization)
+        private readonly T6 m_Item6; // Do not rename (binary serialization)
+        private readonly T7 m_Item7; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
@@ -1053,16 +1060,17 @@ namespace System
     }
 
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
     public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
     {
-        private readonly T1 m_Item1;
-        private readonly T2 m_Item2;
-        private readonly T3 m_Item3;
-        private readonly T4 m_Item4;
-        private readonly T5 m_Item5;
-        private readonly T6 m_Item6;
-        private readonly T7 m_Item7;
-        private readonly TRest m_Rest;
+        private readonly T1 m_Item1; // Do not rename (binary serialization)
+        private readonly T2 m_Item2; // Do not rename (binary serialization)
+        private readonly T3 m_Item3; // Do not rename (binary serialization)
+        private readonly T4 m_Item4; // Do not rename (binary serialization)
+        private readonly T5 m_Item5; // Do not rename (binary serialization)
+        private readonly T6 m_Item6; // Do not rename (binary serialization)
+        private readonly T7 m_Item7; // Do not rename (binary serialization)
+        private readonly TRest m_Rest; // Do not rename (binary serialization)
 
         public T1 Item1 { get { return m_Item1; } }
         public T2 Item2 { get { return m_Item2; } }
diff --git a/src/mscorlib/src/System/UInt16.cs b/src/mscorlib/src/System/UInt16.cs
index c7be2e9a1f..746ed7ba49 100644
--- a/src/mscorlib/src/System/UInt16.cs
+++ b/src/mscorlib/src/System/UInt16.cs
@@ -21,6 +21,7 @@ namespace System
     // Wrapper for unsigned 16 bit integers.
     [Serializable]
     [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct UInt16 : IComparable, IFormattable, IConvertible
             , IComparable<UInt16>, IEquatable<UInt16>
     {
diff --git a/src/mscorlib/src/System/UInt32.cs b/src/mscorlib/src/System/UInt32.cs
index 2731047e06..f696816b98 100644
--- a/src/mscorlib/src/System/UInt32.cs
+++ b/src/mscorlib/src/System/UInt32.cs
@@ -23,6 +23,7 @@ namespace System
     // * Wrapper for unsigned 32 bit integers.
     [Serializable]
     [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct UInt32 : IComparable, IFormattable, IConvertible
         , IComparable<UInt32>, IEquatable<UInt32>
     {
diff --git a/src/mscorlib/src/System/UInt64.cs b/src/mscorlib/src/System/UInt64.cs
index a54bb69ba4..03cdcc5f40 100644
--- a/src/mscorlib/src/System/UInt64.cs
+++ b/src/mscorlib/src/System/UInt64.cs
@@ -21,6 +21,7 @@ namespace System
     // Wrapper for unsigned 64 bit integers.
     [Serializable]
     [CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct UInt64 : IComparable, IFormattable, IConvertible
             , IComparable<UInt64>, IEquatable<UInt64>
     {
diff --git a/src/mscorlib/src/System/UIntPtr.cs b/src/mscorlib/src/System/UIntPtr.cs
index 08e494297b..1bed651e6f 100644
--- a/src/mscorlib/src/System/UIntPtr.cs
+++ b/src/mscorlib/src/System/UIntPtr.cs
@@ -21,9 +21,10 @@ namespace System
 
     [Serializable]
     [CLSCompliant(false)]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
     {
-        unsafe private void* _value;
+        unsafe private void* _value; // Do not rename (binary serialization)
 
         public static readonly UIntPtr Zero;
 
diff --git a/src/mscorlib/src/System/ValueType.cs b/src/mscorlib/src/System/ValueType.cs
index 0cd08bd26f..e5b5528314 100644
--- a/src/mscorlib/src/System/ValueType.cs
+++ b/src/mscorlib/src/System/ValueType.cs
@@ -19,6 +19,7 @@ using System.Runtime.Versioning;
 namespace System
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public abstract class ValueType
     {
         public override bool Equals(Object obj)
diff --git a/src/mscorlib/src/System/WeakReference.cs b/src/mscorlib/src/System/WeakReference.cs
index 60878b8e1c..a6a30c1978 100644
--- a/src/mscorlib/src/System/WeakReference.cs
+++ b/src/mscorlib/src/System/WeakReference.cs
@@ -20,6 +20,7 @@ using System.Diagnostics.Contracts;
 namespace System
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     public class WeakReference : ISerializable
     {
         // If you fix bugs here, please fix them in WeakReference<T> at the same time.
@@ -57,8 +58,8 @@ namespace System
             }
             Contract.EndContractBlock();
 
-            Object target = info.GetValue("TrackedObject", typeof(Object));
-            bool trackResurrection = info.GetBoolean("TrackResurrection");
+            Object target = info.GetValue("TrackedObject", typeof(Object)); // Do not rename (binary serialization)
+            bool trackResurrection = info.GetBoolean("TrackResurrection"); // Do not rename (binary serialization)
 
             Create(target, trackResurrection);
         }
@@ -108,8 +109,8 @@ namespace System
                 throw new ArgumentNullException(nameof(info));
             }
             Contract.EndContractBlock();
-            info.AddValue("TrackedObject", Target, typeof(Object));
-            info.AddValue("TrackResurrection", IsTrackResurrection());
+            info.AddValue("TrackedObject", Target, typeof(Object)); // Do not rename (binary serialization)
+            info.AddValue("TrackResurrection", IsTrackResurrection()); // Do not rename (binary serialization)
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mscorlib/src/System/WeakReferenceOfT.cs b/src/mscorlib/src/System/WeakReferenceOfT.cs
index fbb6f09098..7347683e2f 100644
--- a/src/mscorlib/src/System/WeakReferenceOfT.cs
+++ b/src/mscorlib/src/System/WeakReferenceOfT.cs
@@ -20,6 +20,7 @@ using System.Diagnostics.Contracts;
 namespace System
 {
     [Serializable]
+    [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] 
     // This class is sealed to mitigate security issues caused by Object::MemberwiseClone.
     public sealed class WeakReference<T> : ISerializable
         where T : class
@@ -52,8 +53,8 @@ namespace System
             }
             Contract.EndContractBlock();
 
-            T target = (T)info.GetValue("TrackedObject", typeof(T));
-            bool trackResurrection = info.GetBoolean("TrackResurrection");
+            T target = (T)info.GetValue("TrackedObject", typeof(T)); // Do not rename (binary serialization)
+            bool trackResurrection = info.GetBoolean("TrackResurrection"); // Do not rename (binary serialization)
 
             Create(target, trackResurrection);
         }
@@ -105,8 +106,8 @@ namespace System
             }
             Contract.EndContractBlock();
 
-            info.AddValue("TrackedObject", this.Target, typeof(T));
-            info.AddValue("TrackResurrection", IsTrackResurrection());
+            info.AddValue("TrackedObject", this.Target, typeof(T)); // Do not rename (binary serialization)
+            info.AddValue("TrackResurrection", IsTrackResurrection()); // Do not rename (binary serialization)
         }
 
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
diff --git a/src/mscorlib/src/mscorlib.Friends.cs b/src/mscorlib/src/mscorlib.Friends.cs
index b02b4829d9..709ec21191 100644
--- a/src/mscorlib/src/mscorlib.Friends.cs
+++ b/src/mscorlib/src/mscorlib.Friends.cs
@@ -13,3 +13,5 @@ using System.Runtime.CompilerServices;
 // Depends on WindowsRuntimeImportAttribute
 [assembly: InternalsVisibleTo("System.Runtime.WindowsRuntime.UI.Xaml, PublicKey=00000000000000000400000000000000", AllInternalsVisible = false)]
 
+// Cross framework serialization needs access to internals
+[assembly: InternalsVisibleTo("mscorlib, PublicKey=00000000000000000400000000000000", AllInternalsVisible=false)]
diff --git a/src/pal/src/exception/seh-unwind.cpp b/src/pal/src/exception/seh-unwind.cpp
index ba43c2e725..7746bbbbf5 100644
--- a/src/pal/src/exception/seh-unwind.cpp
+++ b/src/pal/src/exception/seh-unwind.cpp
@@ -266,13 +266,8 @@ BOOL PAL_VirtualUnwind(CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *contextP
     // cannot cross on some systems.
     if ((void*)curPc == g_SEHProcessExceptionReturnAddress)
     {
-        ULONG contextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT | CONTEXT_EXCEPTION_ACTIVE;
-
-    #if defined(_AMD64_)
-        contextFlags |= CONTEXT_XSTATE;
-    #endif
-        size_t nativeContext = *(size_t*)(CONTEXTGetFP(context) + g_common_signal_handler_context_locvar_offset);
-        CONTEXTFromNativeContext((const native_context_t *)nativeContext, context, contextFlags);
+        CONTEXT* signalContext = (CONTEXT*)(CONTEXTGetFP(context) + g_common_signal_handler_context_locvar_offset);
+        memcpy_s(context, sizeof(CONTEXT), signalContext, sizeof(CONTEXT));
 
         return TRUE;
     }
diff --git a/src/pal/src/exception/signal.cpp b/src/pal/src/exception/signal.cpp
index 57ae62ea21..10eecf7b02 100644
--- a/src/pal/src/exception/signal.cpp
+++ b/src/pal/src/exception/signal.cpp
@@ -411,7 +411,27 @@ extern "C" void signal_handler_worker(int code, siginfo_t *siginfo, void *contex
     // TODO: First variable parameter says whether a read (0) or write (non-0) caused the
     // fault. We must disassemble the instruction at record.ExceptionAddress
     // to correctly fill in this value.
+
+    // Unmask the activation signal now that we are running on the original stack of the thread
+    sigset_t signal_set;
+    sigemptyset(&signal_set);
+    sigaddset(&signal_set, INJECT_ACTIVATION_SIGNAL);
+
+    int sigmaskRet = pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL);
+    if (sigmaskRet != 0)
+    {
+        ASSERT("pthread_sigmask failed; error number is %d\n", sigmaskRet);
+    }
+
     returnPoint->returnFromHandler = common_signal_handler(code, siginfo, context, 2, (size_t)0, (size_t)siginfo->si_addr);
+
+    // We are going to return to the alternate stack, so block the activation signal again
+    sigmaskRet = pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
+    if (sigmaskRet != 0)
+    {
+        ASSERT("pthread_sigmask failed; error number is %d\n", sigmaskRet);
+    }
+
     RtlRestoreContext(&returnPoint->context, NULL);
 }
 
@@ -761,12 +781,13 @@ __attribute__((noinline))
 static bool common_signal_handler(int code, siginfo_t *siginfo, void *sigcontext, int numParams, ...)
 {
     sigset_t signal_set;
+    CONTEXT signalContextRecord;
     CONTEXT *contextRecord;
     EXCEPTION_RECORD *exceptionRecord;
     native_context_t *ucontext;
 
     ucontext = (native_context_t *)sigcontext;
-    g_common_signal_handler_context_locvar_offset = (int)((char*)&ucontext - (char*)__builtin_frame_address(0));
+    g_common_signal_handler_context_locvar_offset = (int)((char*)&signalContextRecord - (char*)__builtin_frame_address(0));
 
     AllocateExceptionRecords(&exceptionRecord, &contextRecord);
 
@@ -809,6 +830,9 @@ static bool common_signal_handler(int code, siginfo_t *siginfo, void *sigcontext
     }
 
     contextRecord->ContextFlags |= CONTEXT_EXCEPTION_ACTIVE;
+
+    memcpy_s(&signalContextRecord, sizeof(CONTEXT), contextRecord, sizeof(CONTEXT));
+
     // The exception object takes ownership of the exceptionRecord and contextRecord
     PAL_SEHException exception(exceptionRecord, contextRecord);
 
@@ -852,6 +876,16 @@ void handle_signal(int signal_id, SIGFUNC sigfunc, struct sigaction *previousAct
 #endif  /* HAVE_SIGINFO_T */
     sigemptyset(&newAction.sa_mask);
 
+#ifdef INJECT_ACTIVATION_SIGNAL
+    if ((additionalFlags & SA_ONSTACK) != 0)
+    {
+        // A handler that runs on a separate stack should not be interrupted by the activation signal
+        // until it switches back to the regular stack, since that signal's handler would run on the
+        // limited separate stack and likely run into a stack overflow.
+        sigaddset(&newAction.sa_mask, INJECT_ACTIVATION_SIGNAL);
+    }
+#endif
+
     if (-1 == sigaction(signal_id, &newAction, previousAction))
     {
         ASSERT("handle_signal: sigaction() call failed with error code %d (%s)\n",
diff --git a/src/pal/src/thread/process.cpp b/src/pal/src/thread/process.cpp
index 6db9bf6f51..e22d268cf6 100644
--- a/src/pal/src/thread/process.cpp
+++ b/src/pal/src/thread/process.cpp
@@ -2951,6 +2951,10 @@ PROCAbortInitialize()
             {
                 *argv++ = "--triage";
             }
+            else if (strcmp(envvar, "4") == 0)
+            {
+                *argv++ = "--full";
+            }
         }
 
         envvar = getenv("COMPlus_CreateDumpDiagnostics");
diff --git a/src/pal/tools/gen-buildsys-clang.sh b/src/pal/tools/gen-buildsys-clang.sh
index 944187786f..132be93c7d 100755
--- a/src/pal/tools/gen-buildsys-clang.sh
+++ b/src/pal/tools/gen-buildsys-clang.sh
@@ -173,8 +173,8 @@ cmake \
   "-DCMAKE_NM=$llvm_nm" \
   "-DCMAKE_OBJDUMP=$llvm_objdump" \
   "-DCMAKE_BUILD_TYPE=$buildtype" \
-  "-DCMAKE_ENABLE_CODE_COVERAGE=$code_coverage" \
   "-DCMAKE_EXPORT_COMPILE_COMMANDS=1 " \
+  "-DCLR_CMAKE_ENABLE_CODE_COVERAGE=$code_coverage" \
   "-DCLR_CMAKE_BUILD_TESTS=$build_tests" \
   $cmake_extra_defines \
   $__UnprocessedCMakeArgs \
diff --git a/src/scripts/genEventPipe.py b/src/scripts/genEventPipe.py
index a00511d95d..4c802acaf3 100644
--- a/src/scripts/genEventPipe.py
+++ b/src/scripts/genEventPipe.py
@@ -262,6 +262,8 @@ def generateEventPipeCmakeFile(etwmanifest, eventpipe_directory):
         topCmake.write('            "eventpipehelpers.cpp"\n')
         topCmake.write("""        )
 
+        add_dependencies(eventpipe GeneratedEventingFiles)
+
         # Install the static eventpipe library
         install(TARGETS eventpipe DESTINATION lib)
         """)
diff --git a/src/vm/gcenv.ee.cpp b/src/vm/gcenv.ee.cpp
index 63c4ffea10..c38419807f 100644
--- a/src/vm/gcenv.ee.cpp
+++ b/src/vm/gcenv.ee.cpp
@@ -1325,10 +1325,13 @@ void GCToEEInterface::StompWriteBarrier(WriteBarrierParameters* args)
         VolatileStore(&g_highest_address, args->highest_address);
         ::StompWriteBarrierResize(true, false);
 
-        // g_ephemeral_low/high aren't needed for the write barrier stomp, but they
-        // are needed in other places.
+        // StompWriteBarrierResize does not necessarily bash g_ephemeral_low
+        // usages, so we must do so here. This is particularly true on x86,
+        // where StompWriteBarrierResize will not bash g_ephemeral_low when
+        // called with the parameters (true, false), as it is above.
         g_ephemeral_low = args->ephemeral_low;
         g_ephemeral_high = args->ephemeral_high;
+        ::StompWriteBarrierEphemeral(true);
         return;
     case WriteBarrierOp::SwitchToWriteWatch:
 #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
diff --git a/src/vm/object.cpp b/src/vm/object.cpp
index 3e3f6d120a..4c08f0254e 100644
--- a/src/vm/object.cpp
+++ b/src/vm/object.cpp
@@ -2954,8 +2954,9 @@ void __fastcall ZeroMemoryInGCHeap(void* mem, size_t size)
         *memBytes++ = 0;
 
     // now write pointer sized pieces
+    // volatile ensures that this doesn't get optimized back into a memset call (see #12207)
     size_t nPtrs = (endBytes - memBytes) / sizeof(PTR_PTR_VOID);
-    PTR_PTR_VOID memPtr = (PTR_PTR_VOID) memBytes;
+    volatile PTR_PTR_VOID memPtr = (PTR_PTR_VOID) memBytes;
     for (size_t i = 0; i < nPtrs; i++)
         *memPtr++ = 0;
 
diff --git a/tests/dir.props b/tests/dir.props
index 96c3b2a6d9..50b752ed77 100644
--- a/tests/dir.props
+++ b/tests/dir.props
@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <!--
     $(OS) is set to Unix/Windows_NT. This comes from an environment variable on Windows and MSBuild on Unix.
@@ -64,9 +65,14 @@
   <!-- Provides properties for dependency versions and configures dependency verification/auto-upgrade. -->
   <Import Project="$(ProjectDir)..\dependencies.props" />
 
+  <!-- Use Roslyn Compilers to build -->
+  <Import Project="$(RoslynPropsFile)" Condition="'$(RunningOnUnix)'!='true' and Exists('$(RoslynPropsFile)') and '$(UseRoslynCompilers)'!='false'" />
+  <Import Project="$(RoslynPropsFile)" Condition="'$(RunningOnUnix)'=='true' and Exists('$(RoslynPropsFile)')" />
+
+
    <ItemGroup> 
      <!-- Need to escape double forward slash (%2F) or MSBuild will normalize to one slash on Unix. -->
-     <DotnetSourceList Include="$(PackagesDir)AzureTransfer\$(__BuildType)\pkg\" Condition="'$(OverwriteCoreClrPackageVersion)' == 'true'" />
+     <DotnetSourceList Include="$(PackagesDir)AzureTransfer\" Condition="'$(OverwriteCoreClrPackageVersion)' == 'true'" />
      <DotnetSourceList Include="https:%2F%2Fdotnet.myget.org/F/dotnet-corefxlab/api/v3/index.json" />
      <DotnetSourceList Include="https:%2F%2Fdotnet.myget.org/F/dotnet-core/api/v3/index.json" /> 
      <DotnetSourceList Include="https:%2F%2Fapi.nuget.org/v3/index.json" /> 
diff --git a/tests/runtest.sh b/tests/runtest.sh
index 439bbb66e6..82bbaff7e7 100755
--- a/tests/runtest.sh
+++ b/tests/runtest.sh
@@ -1202,6 +1202,18 @@ else
     load_failing_tests
 fi
 
+# Other architectures are not supported yet.
+if [ "$ARCH" == "x64" ]
+then
+    scriptPath=$(dirname $0)
+    ${scriptPath}/setup-stress-dependencies.sh --outputDir=$coreOverlayDir
+else
+    if [ "$ARCH" != "arm64" ]
+    then
+        echo "Skip preparing for GC stress test. Dependent package is not supported on this architecture."
+    fi
+fi
+
 export __TestEnv=$testEnv
 
 cd "$testRootDir"
diff --git a/tests/scripts/arm32_ci_script.sh b/tests/scripts/arm32_ci_script.sh
index 98f35066d4..e73e266fdb 100755
--- a/tests/scripts/arm32_ci_script.sh
+++ b/tests/scripts/arm32_ci_script.sh
@@ -289,9 +289,14 @@ function cross_build_coreclr_with_docker {
         sudo chown -R $(id -u -n) cross/rootfs
     fi
 
+    __extraArgs=""
+    if [[ "$__buildArch" == "armel" && "$__linuxCodeName" == "tizen" ]]; then
+        __extraArgs="cmakeargs -DFEATURE_GDBJIT=TRUE -PortableBuild=false"
+    fi
+
     # Cross building coreclr with rootfs in Docker
     (set +x; echo "Start cross build coreclr for $__buildArch $__linuxCodeName")
-    __buildCmd="./build.sh $__buildArch cross $__verboseFlag $__skipMscorlib $__buildConfig -rebuild"
+    __buildCmd="./build.sh $__buildArch cross $__verboseFlag $__skipMscorlib $__buildConfig $__extraArgs -rebuild"
     $__dockerCmd $__buildCmd
     sudo chown -R $(id -u -n) ./bin
 }
diff --git a/tests/scripts/perf-prep.sh b/tests/scripts/perf-prep.sh
index 4468dbb6f7..6882d8f6a3 100755
--- a/tests/scripts/perf-prep.sh
+++ b/tests/scripts/perf-prep.sh
@@ -64,27 +64,25 @@ python3.5 --version
 python3.5 ./tests/scripts/Microsoft.BenchView.JSONFormat/tools/machinedata.py
 
 if [ $throughput -eq 1 ]; then
-    # Clone corefx
-    if [ -d "_" ]; then
-        rm -r -f _
+    # Download throughput benchmarks
+    if [ -d "Microsoft.Benchview.ThroughputBenchmarks.x64.Windows_NT" ]; then
+        rm -r -f Microsoft.Benchview.ThroughputBenchmarks.x64.Windows_NT
     fi
-    mkdir _
-    git clone https://github.com/dotnet/corefx.git _/fx
-    cd _/fx
+    mkdir Microsoft.Benchview.ThroughputBenchmarks.x64.Windows_NT
+    cd Microsoft.Benchview.ThroughputBenchmarks.x64.Windows_NT
 
-    # Checkout the specific commit we want
-    git checkout f0b9e238c08f62a1db90ef0378980ac771204d35
+    curl -OL https://dotnet.myget.org/F/dotnet-core/api/v2/package/Microsoft.Benchview.ThroughputBenchmarks.x64.Windows_NT/1.0.0
+    mv 1.0.0 1.0.0.zip
+    unzip -q 1.0.0.zip
 
-    # Build
-    ./build.sh -release
 else
     # Set up the copies
     # Coreclr build containing the tests and mscorlib
-    curl https://ci.dot.net/job/$perfBranch/job/master/job/release_windows_nt/lastSuccessfulBuild/artifact/bin/tests/tests.zip -o tests.zip
+    curl https://ci.dot.net/job/$perfBranch/job/release_2.0.0/job/release_windows_nt/lastSuccessfulBuild/artifact/bin/tests/tests.zip -o tests.zip
 
     # Corefx components.  We now have full stack builds on all distros we test here, so we can copy straight from CoreFX jobs.
     mkdir corefx
-    curl https://ci.dot.net/job/dotnet_corefx/job/master/job/ubuntu14.04_release/lastSuccessfulBuild/artifact/bin/build.tar.gz -o ./corefx/build.tar.gz
+    curl https://ci.dot.net/job/dotnet_corefx/job/release_2.0.0/job/ubuntu14.04_release/lastSuccessfulBuild/artifact/bin/build.tar.gz -o ./corefx/build.tar.gz
 
     # Unpack the corefx binaries
     pushd corefx > /dev/null
diff --git a/tests/setup-stress-dependencies.cmd b/tests/setup-stress-dependencies.cmd
new file mode 100644
index 0000000000..0770e858a5
--- /dev/null
+++ b/tests/setup-stress-dependencies.cmd
@@ -0,0 +1,117 @@
+@if not defined _echo @echo off
+setlocal
+
+set __ThisScriptShort=%0
+set __ThisScriptFull=%~f0
+set __ThisScriptPath=%~dp0
+
+REM =========================================================================================
+REM ===
+REM === Parse arguments
+REM ===
+REM =========================================================================================
+
+set __OutputDir=
+set __Arch= 
+
+:Arg_Loop
+if "%1" == "" goto ArgsDone
+
+if /i "%1" == "/?"    goto Usage
+if /i "%1" == "-?"    goto Usage
+if /i "%1" == "/h"    goto Usage
+if /i "%1" == "-h"    goto Usage
+if /i "%1" == "/help" goto Usage
+if /i "%1" == "-help" goto Usage
+
+if /i "%1" == "/arch"             (set __Arch=%2&shift&shift&goto Arg_Loop) 
+if /i "%1" == "/outputdir"        (set __OutputDir=%2&shift&shift&goto Arg_Loop)
+
+echo Invalid command-line argument: %1
+goto Usage
+
+:ArgsDone
+
+if not defined __OutputDir goto Usage
+if not defined __Arch goto Usage 
+
+REM Check if the platform is supported
+if /i %__Arch% == "arm" (
+    echo No runtime dependencies for Arm32.
+    exit /b 0
+    )
+
+REM =========================================================================================
+REM ===
+REM === Check if dotnet CLI and necessary directories exist
+REM ===
+REM =========================================================================================
+
+set __DotNetToolDir=%__ThisScriptPath%..\Tools
+set __DotNetCmd=%__DotNetToolDir%\dotnetcli\dotnet.exe 
+set __PackageDir=%__ThisScriptPath%..\Packages
+set __CsprojPath=%__ThisScriptPath%\src\Common\stress_dependencies\stress_dependencies.csproj
+
+REM Check if dotnet cli exists
+if not exist "%__DotNetToolDir%" (
+    echo Directory containing dotnet CLI does not exist: %__DotNetToolDir%
+    goto Fail
+)
+if not exist "%__DotNetCmd%" (
+    echo dotnet.exe does not exist: %__DotNetCmd%
+    goto Fail
+)
+
+REM Create directories needed
+if not exist "%__PackageDir%" md "%__PackageDir%"
+if not exist "%__OutputDir%" md "%__OutputDir%"
+
+REM =========================================================================================
+REM ===
+REM === Download packages
+REM ===
+REM =========================================================================================
+
+REM Download the package
+echo Downloading CoreDisTools package
+set DOTNETCMD="%__DotNetCmd%" restore "%__CsprojPath%" --source https://dotnet.myget.org/F/dotnet-core/ --packages "%__PackageDir%"
+echo %DOTNETCMD%
+call %DOTNETCMD%
+if errorlevel 1 goto Fail
+
+REM Get downloaded dll path
+echo Locating coredistools.dll
+FOR /F "delims=" %%i IN ('dir %__PackageDir%\coredistools.dll /b/s ^| findstr /R "runtime.win[0-9]*-%__Arch%"') DO set __LibPath=%%i
+echo CoreDisTools library path: %__LibPath%
+if not exist "%__LibPath%" (
+    echo Failed to locate the downloaded library: %__LibPath%
+    goto Fail
+)
+
+REM Copy library to output directory
+echo Copy library: %__LibPath% to %__OutputDir%
+copy /y "%__LibPath%" "%__OutputDir%"
+if errorlevel 1 (
+    echo Failed to copy %__LibPath% to %__OutputDir%
+    goto Fail
+)
+
+exit /b 0
+
+:Fail
+exit /b 1
+
+REM =========================================================================================
+REM ===
+REM === Helper routines
+REM ===
+REM =========================================================================================
+
+:Usage
+echo.
+echo Download coredistools for GC stress testing
+echo.
+echo Usage:
+echo     %__ThisScriptShort% /arch ^<TargetArch^> /outputdir ^<coredistools_lib_install_path^>
+echo.
+exit /b 1
\ No newline at end of file
diff --git a/tests/setup-stress-dependencies.sh b/tests/setup-stress-dependencies.sh
new file mode 100755
index 0000000000..a7f3c498c1
--- /dev/null
+++ b/tests/setup-stress-dependencies.sh
@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# set -x
+
+#
+# Constants
+#
+readonly EXIT_CODE_SUCCESS=0
+
+#
+# This script should be located in coreclr/tests.
+#
+
+function print_usage {
+    echo ''
+    echo 'Download coredistools for GC stress testing'
+    echo ''
+    echo 'Command line:'
+    echo ''
+    echo './setup-gcstress.sh --outputDir=<coredistools_lib_install_path>'
+    echo ''
+    echo 'Required arguments:'
+    echo '  --outputDir=<path>         : Directory to install libcoredistools.so'
+    echo ''
+}
+
+function exit_with_error {
+    local errorCode=$1
+    local errorMsg=$2
+
+    if [ ! -z "$2" ]; then
+        echo $2
+    fi
+    
+    exit $errorCode
+}
+
+function handle_ctrl_c {
+    exit_with_error 1 'Aborted by Ctrl+C'
+ }
+
+# Register the Ctrl-C handler
+trap handle_ctrl_c INT
+
+# Argument variables
+libInstallDir=
+
+# Handle arguments
+verbose=0
+for i in "$@"
+do
+    case $i in
+        -h|--help)
+            exit $EXIT_CODE_SUCCESS
+            ;;
+        -v|--verbose)
+            verbose=1
+            ;;
+        --outputDir=*)
+            libInstallDir=${i#*=}
+            ;;
+        *)
+            echo "Unknown switch: $i"
+            print_usage
+            exit $EXIT_CODE_SUCCESS
+            ;;
+    esac
+done
+
+if [ -z "$libInstallDir" ]; then
+    echo "--libInstallDir is required."
+    print_usage
+    exit_with_error 1
+fi
+
+# This script must be located in coreclr/tests.
+scriptDir=$(cd "$(dirname "$0")"; pwd -P)
+
+echo "Running init-tools.sh"
+$scriptDir/../init-tools.sh
+
+dotnetToolsDir=$scriptDir/../Tools
+dotnetCmd=${dotnetToolsDir}/dotnetcli/dotnet
+packageDir=${scriptDir}/../packages
+csprojPath=${scriptDir}/src/Common/stress_dependencies/stress_dependencies.csproj
+
+# Check tool directory
+if [ ! -e $dotnetToolsDir ]; then
+    exit_with_error 1 'Directory containing dotnet commandline does not exist:'$dotnetToolsDir 
+fi
+if [ ! -e $dotnetCmd ]; then
+    exit_with_error 1 'dotnet commandline does not exist:'$dotnetCmd
+fi
+
+# make package directory
+if [ ! -e $packageDir ]; then
+    mkdir -p $packageDir
+fi
+
+# make output directory
+if [ ! -e $libInstallDir ]; then
+    mkdir -p $libInstallDir
+fi
+
+# Query runtime Id
+rid=`$dotnetCmd --info | grep 'RID:' | sed 's/^ *RID: *//g'`  
+if [ -z "$rid" ]; then
+    exit_with_error 1 "Failed to query runtime Id"
+fi    
+
+# Download the package
+echo Downloading CoreDisTools package
+bash -c -x "$dotnetCmd restore $csprojPath --source https://dotnet.myget.org/F/dotnet-core/ --packages $packageDir"
+if [ $? -ne 0 ]
+then
+    exit_with_error 1 "Failed to restore the package"
+fi
+
+# Get library path
+libPath=`find $packageDir | grep $rid | grep -m 1 libcoredistools`
+if [ ! -e $libPath ]; then
+    exit_with_error 1 'Failed to locate the downloaded library'
+fi
+
+# Copy library to output directory
+echo 'Copy library:' $libPath '-->' $libInstallDir/
+cp -f $libPath $libInstallDir
+if [ $? -ne 0 ]
+then
+    exit_with_error 1 "Failed to copy the library"
+fi
+
+# Return success
+exit $EXIT_CODE_SUCCESS
diff --git a/tests/src/CLRTest.CrossGen.targets b/tests/src/CLRTest.CrossGen.targets
index 6bb5cdb103..eab4f056fd 100644
--- a/tests/src/CLRTest.CrossGen.targets
+++ b/tests/src/CLRTest.CrossGen.targets
@@ -103,4 +103,4 @@ if defined RunCrossGen (
 
 
   
-</Project>
+</Project>
\ No newline at end of file
diff --git a/tests/src/CLRTest.Execute.Bash.targets b/tests/src/CLRTest.Execute.Bash.targets
index f95408f512..1ce7b845ee 100644
--- a/tests/src/CLRTest.Execute.Bash.targets
+++ b/tests/src/CLRTest.Execute.Bash.targets
@@ -255,9 +255,15 @@ fi
 ExePath=$(InputAssemblyName)
 $(BashLinkerTestLaunchCmds)
 $(BashCLRTestLaunchCmds)
+if [ ! -z ${RunCrossGen+x} ]%3B then
+  TakeLock
+fi
 echo $_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
 $_DebuggerFullPath $(_CLRTestRunFile) $ExePath $CLRTestExecutionArguments 
 CLRTestExitCode=$?
+if [ ! -z ${RunCrossGen+x} ]%3B then
+  ReleaseLock
+fi
 $(BashLinkerTestCleanupCmds)
       ]]></BashCLRTestLaunchCmds>
       <BashCLRTestLaunchCmds Condition="'$(CLRTestKind)' == 'RunOnly'"><![CDATA[
@@ -394,4 +400,4 @@ $(BashCLRTestExitCodeCheck)
       Overwrite="true" />
   </Target>
   
-</Project>
+</Project>
\ No newline at end of file
diff --git a/tests/src/CLRTest.Execute.Batch.targets b/tests/src/CLRTest.Execute.Batch.targets
index 545fc72eb2..dfd87bad5f 100644
--- a/tests/src/CLRTest.Execute.Batch.targets
+++ b/tests/src/CLRTest.Execute.Batch.targets
@@ -261,9 +261,15 @@ set ExePath=$(InputAssemblyName)
 $(BatchLinkerTestLaunchCmds)
 $(BatchCLRTestLaunchCmds)
 
+if defined RunCrossGen (
+  call :TakeLock
+)
 ECHO %LAUNCHER% %ExePath% %CLRTestExecutionArguments%
 %LAUNCHER% %ExePath% %CLRTestExecutionArguments%
 set CLRTestExitCode=!ERRORLEVEL!
+if defined RunCrossGen (
+  call :ReleaseLock
+)
 $(BatchLinkerTestCleanupCmds)
       ]]></BatchCLRTestLaunchCmds>
 
@@ -385,4 +391,4 @@ $(BatchCLRTestExitCodeCheck)
       Overwrite="true" />
   </Target>
   
-</Project>
+</Project>
\ No newline at end of file
diff --git a/tests/src/Common/stress_dependencies/stress_dependencies.csproj b/tests/src/Common/stress_dependencies/stress_dependencies.csproj
new file mode 100644
index 0000000000..e33ee1efd3
--- /dev/null
+++ b/tests/src/Common/stress_dependencies/stress_dependencies.csproj
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <CLRTestKind>BuildOnly</CLRTestKind>
+    <NugetTargetMoniker>.NETCoreApp,Version=v2.0</NugetTargetMoniker>
+    <NugetTargetMonikerShort>netcoreapp2.0</NugetTargetMonikerShort>
+    <IsTestProject>false</IsTestProject>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETCore.CoreDisTools">
+      <Version>1.0.1-prerelease-*</Version>
+    </PackageReference>
+  </ItemGroup>
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
+    <PackageTargetFallback>$(PackageTargetFallback);dnxcore50</PackageTargetFallback>
+    <RuntimeIdentifiers>win7-x64;ubuntu.14.04-x64;osx.10.10-x64;win7-x86;ubuntu.14.04-x86;osx.10.10-x86</RuntimeIdentifiers>
+    <ContainsPackageReferences>true</ContainsPackageReferences>
+    <PrereleaseResolveNuGetPackages>false</PrereleaseResolveNuGetPackages>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+  <Target Name="Build"
+     DependsOnTargets="ResolveReferences" />
+</Project>
\ No newline at end of file
diff --git a/tests/src/Common/test_dependencies/test_dependencies.csproj b/tests/src/Common/test_dependencies/test_dependencies.csproj
index f5b1b319c7..7fc3abdc1c 100644
--- a/tests/src/Common/test_dependencies/test_dependencies.csproj
+++ b/tests/src/Common/test_dependencies/test_dependencies.csproj
@@ -10,9 +10,6 @@
     <IsTestProject>false</IsTestProject>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NETCore.CoreDisTools">
-      <Version>1.0.1-prerelease-*</Version>
-    </PackageReference>
     <PackageReference Include="Microsoft.Private.CoreFx.NETCoreApp">
       <Version>4.4.0-$(CoreFxExpectedPrerelease)</Version>
     </PackageReference>
@@ -30,11 +27,11 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
     <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
     <PackageTargetFallback>$(PackageTargetFallback);dnxcore50;netcoreapp1.1;portable-net45+win8</PackageTargetFallback>
-    <RuntimeIdentifiers>win-x64;win-x86;win7-x86;win7-x64;ubuntu.14.04-x64;ubuntu.16.04-x64;ubuntu.16.10-x64;osx.10.12-x64;osx-x64;centos.7-x64;rhel.7-x64;debian.8-x64;fedora.24-x64;linux-x64</RuntimeIdentifiers>
+    <RuntimeIdentifiers>win-x64;win-x86;win7-x86;win7-x64;win-arm64;win-arm;win7-arm64;win7-arm;ubuntu.14.04-x64;ubuntu.16.04-x64;ubuntu.16.10-x64;osx.10.12-x64;osx-x64;centos.7-x64;rhel.7-x64;debian.8-x64;fedora.24-x64;linux-x64</RuntimeIdentifiers>
     <ContainsPackageReferences>true</ContainsPackageReferences>
     <PrereleaseResolveNuGetPackages>false</PrereleaseResolveNuGetPackages>
   </PropertyGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
   <Target Name="Build"
      DependsOnTargets="ResolveReferences" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/tests/src/Common/test_runtime/test_runtime.csproj b/tests/src/Common/test_runtime/test_runtime.csproj
index 0212b05274..4807adf7a9 100644
--- a/tests/src/Common/test_runtime/test_runtime.csproj
+++ b/tests/src/Common/test_runtime/test_runtime.csproj
@@ -30,7 +30,7 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
     <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
     <PackageTargetFallback>$(PackageTargetFallback);dnxcore50;portable-net45+win8</PackageTargetFallback>
-    <RuntimeIdentifiers>win-x64;win-x86;win7-x86;win7-x64;ubuntu.14.04-x64;ubuntu.16.04-x64;ubuntu.16.10-x64;osx.10.12-x64;osx-x64;centos.7-x64;rhel.7-x64;debian.8-x64;fedora.24-x64;linux-x64</RuntimeIdentifiers>
+    <RuntimeIdentifiers>win-x64;win-x86;win7-x86;win7-x64;win-arm64;win-arm;win7-arm64;win7-arm;ubuntu.14.04-x64;ubuntu.16.04-x64;ubuntu.16.10-x64;osx.10.12-x64;osx-x64;centos.7-x64;rhel.7-x64;debian.8-x64;fedora.24-x64;linux-x64</RuntimeIdentifiers>
     <ContainsPackageReferences>true</ContainsPackageReferences>
     <PrereleaseResolveNuGetPackages>false</PrereleaseResolveNuGetPackages>
   </PropertyGroup>
diff --git a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteByte.csproj b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteByte.csproj
index 4a206ae9a0..c78ffefd05 100644
--- a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteByte.csproj
+++ b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteByte.csproj
@@ -11,6 +11,9 @@
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
 
+    <!-- This test is disabled until #12224 is fixed -->
+    <GCStressIncompatible>true</GCStressIncompatible>
+
     <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
diff --git a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt16.csproj b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt16.csproj
index b540fb180d..fc63d21d4e 100644
--- a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt16.csproj
+++ b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt16.csproj
@@ -11,6 +11,9 @@
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
 
+    <!-- This test is disabled until #12224 is fixed -->
+    <GCStressIncompatible>true</GCStressIncompatible>
+
     <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
diff --git a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt32.csproj b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt32.csproj
index 7b6a948b61..0aea271102 100644
--- a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt32.csproj
+++ b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt32.csproj
@@ -11,6 +11,9 @@
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
 
+    <!-- This test is disabled until #12224 is fixed -->
+    <GCStressIncompatible>true</GCStressIncompatible>
+
     <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
diff --git a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt64.csproj b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt64.csproj
index 91e6ea75c7..685368be92 100644
--- a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt64.csproj
+++ b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteInt64.csproj
@@ -11,6 +11,9 @@
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
 
+    <!-- This test is disabled until #12224 is fixed -->
+    <GCStressIncompatible>true</GCStressIncompatible>
+
     <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
diff --git a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteIntPtr.csproj b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteIntPtr.csproj
index 366a5c5f27..5287d8853d 100644
--- a/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteIntPtr.csproj
+++ b/tests/src/Interop/MarshalAPI/ReadWrite/ReadWriteIntPtr.csproj
@@ -11,6 +11,9 @@
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
 
+    <!-- This test is disabled until #12224 is fixed -->
+    <GCStressIncompatible>true</GCStressIncompatible>
+
     <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
diff --git a/tests/src/JIT/Directed/nullabletypes/isinst.cs b/tests/src/JIT/Directed/nullabletypes/isinst.cs
index b747f484c2..9a7b496907 100644
--- a/tests/src/JIT/Directed/nullabletypes/isinst.cs
+++ b/tests/src/JIT/Directed/nullabletypes/isinst.cs
@@ -28,26 +28,26 @@ internal class Program
             Eval(0006, v is NotEmptyStruct[], false);
             Eval(0007, v is NotEmptyStruct?, false);
             Eval(0008, v is NotEmptyStruct?[], false);
-            Eval(0009, v is EmptyStructGen<int>, false);
-            Eval(0010, v is EmptyStructGen<int>[], false);
-            Eval(0011, v is EmptyStructGen<int>?, false);
-            Eval(0012, v is EmptyStructGen<int>?[], false);
-            Eval(0013, v is NotEmptyStructGen<Guid>, false);
-            Eval(0014, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0015, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0016, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0017, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0018, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0019, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(0020, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0009, v is EmptyStructGen<int>, false);
+//            Eval(0010, v is EmptyStructGen<int>[], false);
+//            Eval(0011, v is EmptyStructGen<int>?, false);
+//            Eval(0012, v is EmptyStructGen<int>?[], false);
+//            Eval(0013, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0014, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0015, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0016, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0017, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0018, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0019, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(0020, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(0021, v is NestedStruct, false);
             Eval(0022, v is NestedStruct[], false);
             Eval(0023, v is NestedStruct?, false);
             Eval(0024, v is NestedStruct?[], false);
-            Eval(0025, v is NestedStructGen<Decimal>, false);
-            Eval(0026, v is NestedStructGen<Decimal>[], false);
-            Eval(0027, v is NestedStructGen<Decimal>?, false);
-            Eval(0028, v is NestedStructGen<Decimal>?[], false);
+//            Eval(0025, v is NestedStructGen<Decimal>, false);
+//            Eval(0026, v is NestedStructGen<Decimal>[], false);
+//            Eval(0027, v is NestedStructGen<Decimal>?, false);
+//            Eval(0028, v is NestedStructGen<Decimal>?[], false);
             Eval(0029, v is ExplicitFieldOffsetStruct, false);
             Eval(0030, v is ExplicitFieldOffsetStruct[], false);
             Eval(0031, v is ExplicitFieldOffsetStruct?, false);
@@ -64,18 +64,18 @@ internal class Program
             Eval(0050, v is ImplementTwoInterface[], false);
             Eval(0051, v is ImplementTwoInterface?, false);
             Eval(0052, v is ImplementTwoInterface?[], false);
-            Eval(0053, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(0054, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(0055, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(0056, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(0057, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(0058, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(0059, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(0060, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(0061, v is ImplementAllInterface<int>, false);
-            Eval(0062, v is ImplementAllInterface<int>[], false);
-            Eval(0063, v is ImplementAllInterface<int>?, false);
-            Eval(0064, v is ImplementAllInterface<int>?[], false);
+//            Eval(0053, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(0054, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(0055, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(0056, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(0057, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(0058, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(0059, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(0060, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(0061, v is ImplementAllInterface<int>, false);
+//            Eval(0062, v is ImplementAllInterface<int>[], false);
+//            Eval(0063, v is ImplementAllInterface<int>?, false);
+//            Eval(0064, v is ImplementAllInterface<int>?[], false);
             Eval(0065, v is IntE, false);
             Eval(0066, v is IntE[], false);
             Eval(0067, v is IntE?, false);
@@ -174,38 +174,38 @@ internal class Program
             Eval(0160, v is IEmpty[], false);
             Eval(0161, v is INotEmpty, false);
             Eval(0162, v is INotEmpty[], false);
-            Eval(0163, v is IEmptyGen<int>, false);
-            Eval(0164, v is IEmptyGen<int>[], false);
-            Eval(0165, v is INotEmptyGen<int>, false);
-            Eval(0166, v is INotEmptyGen<int>[], false);
+//            Eval(0163, v is IEmptyGen<int>, false);
+//            Eval(0164, v is IEmptyGen<int>[], false);
+//            Eval(0165, v is INotEmptyGen<int>, false);
+//            Eval(0166, v is INotEmptyGen<int>[], false);
             Eval(0167, v is SimpleDelegate, false);
             Eval(0168, v is SimpleDelegate[], false);
-            Eval(0169, v is GenericDelegate<int>, false);
-            Eval(0170, v is GenericDelegate<int>[], false);
+//            Eval(0169, v is GenericDelegate<int>, false);
+//            Eval(0170, v is GenericDelegate<int>[], false);
             Eval(0171, v is EmptyClass, false);
             Eval(0172, v is EmptyClass[], false);
             Eval(0173, v is NotEmptyClass, false);
             Eval(0174, v is NotEmptyClass[], false);
-            Eval(0175, v is EmptyClassGen<int>, false);
-            Eval(0176, v is EmptyClassGen<int>[], false);
-            Eval(0177, v is NotEmptyClassGen<Guid>, false);
-            Eval(0178, v is NotEmptyClassGen<Guid>[], false);
-            Eval(0179, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(0180, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(0175, v is EmptyClassGen<int>, false);
+//            Eval(0176, v is EmptyClassGen<int>[], false);
+//            Eval(0177, v is NotEmptyClassGen<Guid>, false);
+//            Eval(0178, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(0179, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(0180, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(0181, v is NestedClass, false);
             Eval(0182, v is NestedClass[], false);
-            Eval(0183, v is NestedClassGen<Decimal>, false);
-            Eval(0184, v is NestedClassGen<Decimal>[], false);
+//            Eval(0183, v is NestedClassGen<Decimal>, false);
+//            Eval(0184, v is NestedClassGen<Decimal>[], false);
             Eval(0185, v is ImplementOneInterfaceC, false);
             Eval(0186, v is ImplementOneInterfaceC[], false);
             Eval(0187, v is ImplementTwoInterfaceC, false);
             Eval(0188, v is ImplementTwoInterfaceC[], false);
-            Eval(0189, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(0190, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(0191, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(0192, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(0193, v is ImplementAllInterfaceC<int>, false);
-            Eval(0194, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(0189, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(0190, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(0191, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(0192, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(0193, v is ImplementAllInterfaceC<int>, false);
+//            Eval(0194, v is ImplementAllInterfaceC<int>[], false);
             Eval(0195, v is SealedClass, false);
             Eval(0196, v is SealedClass[], false);
         }
@@ -219,26 +219,26 @@ internal class Program
             Eval(0202, v is NotEmptyStruct[], false);
             Eval(0203, v is NotEmptyStruct?, false);
             Eval(0204, v is NotEmptyStruct?[], false);
-            Eval(0205, v is EmptyStructGen<int>, false);
-            Eval(0206, v is EmptyStructGen<int>[], false);
-            Eval(0207, v is EmptyStructGen<int>?, false);
-            Eval(0208, v is EmptyStructGen<int>?[], false);
-            Eval(0209, v is NotEmptyStructGen<Guid>, false);
-            Eval(0210, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0211, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0212, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0213, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0214, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0215, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(0216, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0205, v is EmptyStructGen<int>, false);
+//            Eval(0206, v is EmptyStructGen<int>[], false);
+//            Eval(0207, v is EmptyStructGen<int>?, false);
+//            Eval(0208, v is EmptyStructGen<int>?[], false);
+//            Eval(0209, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0210, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0211, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0212, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0213, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0214, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0215, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(0216, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(0217, v is NestedStruct, false);
             Eval(0218, v is NestedStruct[], false);
             Eval(0219, v is NestedStruct?, false);
             Eval(0220, v is NestedStruct?[], false);
-            Eval(0221, v is NestedStructGen<Decimal>, false);
-            Eval(0222, v is NestedStructGen<Decimal>[], false);
-            Eval(0223, v is NestedStructGen<Decimal>?, false);
-            Eval(0224, v is NestedStructGen<Decimal>?[], false);
+//            Eval(0221, v is NestedStructGen<Decimal>, false);
+//            Eval(0222, v is NestedStructGen<Decimal>[], false);
+//            Eval(0223, v is NestedStructGen<Decimal>?, false);
+//            Eval(0224, v is NestedStructGen<Decimal>?[], false);
             Eval(0225, v is ExplicitFieldOffsetStruct, false);
             Eval(0226, v is ExplicitFieldOffsetStruct[], false);
             Eval(0227, v is ExplicitFieldOffsetStruct?, false);
@@ -255,18 +255,18 @@ internal class Program
             Eval(0246, v is ImplementTwoInterface[], false);
             Eval(0247, v is ImplementTwoInterface?, false);
             Eval(0248, v is ImplementTwoInterface?[], false);
-            Eval(0249, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(0250, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(0251, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(0252, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(0253, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(0254, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(0255, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(0256, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(0257, v is ImplementAllInterface<int>, false);
-            Eval(0258, v is ImplementAllInterface<int>[], false);
-            Eval(0259, v is ImplementAllInterface<int>?, false);
-            Eval(0260, v is ImplementAllInterface<int>?[], false);
+//            Eval(0249, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(0250, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(0251, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(0252, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(0253, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(0254, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(0255, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(0256, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(0257, v is ImplementAllInterface<int>, false);
+//            Eval(0258, v is ImplementAllInterface<int>[], false);
+//            Eval(0259, v is ImplementAllInterface<int>?, false);
+//            Eval(0260, v is ImplementAllInterface<int>?[], false);
             Eval(0261, v is IntE, false);
             Eval(0262, v is IntE[], false);
             Eval(0263, v is IntE?, false);
@@ -365,38 +365,38 @@ internal class Program
             Eval(0356, v is IEmpty[], false);
             Eval(0357, v is INotEmpty, false);
             Eval(0358, v is INotEmpty[], false);
-            Eval(0359, v is IEmptyGen<int>, false);
-            Eval(0360, v is IEmptyGen<int>[], false);
-            Eval(0361, v is INotEmptyGen<int>, false);
-            Eval(0362, v is INotEmptyGen<int>[], false);
+//            Eval(0359, v is IEmptyGen<int>, false);
+//            Eval(0360, v is IEmptyGen<int>[], false);
+//            Eval(0361, v is INotEmptyGen<int>, false);
+//            Eval(0362, v is INotEmptyGen<int>[], false);
             Eval(0363, v is SimpleDelegate, false);
             Eval(0364, v is SimpleDelegate[], false);
-            Eval(0365, v is GenericDelegate<int>, false);
-            Eval(0366, v is GenericDelegate<int>[], false);
+//            Eval(0365, v is GenericDelegate<int>, false);
+//            Eval(0366, v is GenericDelegate<int>[], false);
             Eval(0367, v is EmptyClass, false);
             Eval(0368, v is EmptyClass[], false);
             Eval(0369, v is NotEmptyClass, false);
             Eval(0370, v is NotEmptyClass[], false);
-            Eval(0371, v is EmptyClassGen<int>, false);
-            Eval(0372, v is EmptyClassGen<int>[], false);
-            Eval(0373, v is NotEmptyClassGen<Guid>, false);
-            Eval(0374, v is NotEmptyClassGen<Guid>[], false);
-            Eval(0375, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(0376, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(0371, v is EmptyClassGen<int>, false);
+//            Eval(0372, v is EmptyClassGen<int>[], false);
+//            Eval(0373, v is NotEmptyClassGen<Guid>, false);
+//            Eval(0374, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(0375, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(0376, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(0377, v is NestedClass, false);
             Eval(0378, v is NestedClass[], false);
-            Eval(0379, v is NestedClassGen<Decimal>, false);
-            Eval(0380, v is NestedClassGen<Decimal>[], false);
+//            Eval(0379, v is NestedClassGen<Decimal>, false);
+//            Eval(0380, v is NestedClassGen<Decimal>[], false);
             Eval(0381, v is ImplementOneInterfaceC, false);
             Eval(0382, v is ImplementOneInterfaceC[], false);
             Eval(0383, v is ImplementTwoInterfaceC, false);
             Eval(0384, v is ImplementTwoInterfaceC[], false);
-            Eval(0385, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(0386, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(0387, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(0388, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(0389, v is ImplementAllInterfaceC<int>, false);
-            Eval(0390, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(0385, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(0386, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(0387, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(0388, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(0389, v is ImplementAllInterfaceC<int>, false);
+//            Eval(0390, v is ImplementAllInterfaceC<int>[], false);
             Eval(0391, v is SealedClass, false);
             Eval(0392, v is SealedClass[], false);
         }
@@ -410,26 +410,26 @@ internal class Program
             Eval(0398, v is NotEmptyStruct[], false);
             Eval(0399, v is NotEmptyStruct?, false);
             Eval(0400, v is NotEmptyStruct?[], false);
-            Eval(0401, v is EmptyStructGen<int>, false);
-            Eval(0402, v is EmptyStructGen<int>[], false);
-            Eval(0403, v is EmptyStructGen<int>?, false);
-            Eval(0404, v is EmptyStructGen<int>?[], false);
-            Eval(0405, v is NotEmptyStructGen<Guid>, false);
-            Eval(0406, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0407, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0408, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0409, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0410, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0411, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(0412, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0401, v is EmptyStructGen<int>, false);
+//            Eval(0402, v is EmptyStructGen<int>[], false);
+//            Eval(0403, v is EmptyStructGen<int>?, false);
+//            Eval(0404, v is EmptyStructGen<int>?[], false);
+//            Eval(0405, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0406, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0407, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0408, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0409, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0410, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0411, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(0412, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(0413, v is NestedStruct, false);
             Eval(0414, v is NestedStruct[], false);
             Eval(0415, v is NestedStruct?, false);
             Eval(0416, v is NestedStruct?[], false);
-            Eval(0417, v is NestedStructGen<Decimal>, false);
-            Eval(0418, v is NestedStructGen<Decimal>[], false);
-            Eval(0419, v is NestedStructGen<Decimal>?, false);
-            Eval(0420, v is NestedStructGen<Decimal>?[], false);
+//            Eval(0417, v is NestedStructGen<Decimal>, false);
+//            Eval(0418, v is NestedStructGen<Decimal>[], false);
+//            Eval(0419, v is NestedStructGen<Decimal>?, false);
+//            Eval(0420, v is NestedStructGen<Decimal>?[], false);
             Eval(0421, v is ExplicitFieldOffsetStruct, false);
             Eval(0422, v is ExplicitFieldOffsetStruct[], false);
             Eval(0423, v is ExplicitFieldOffsetStruct?, false);
@@ -446,18 +446,18 @@ internal class Program
             Eval(0442, v is ImplementTwoInterface[], false);
             Eval(0443, v is ImplementTwoInterface?, false);
             Eval(0444, v is ImplementTwoInterface?[], false);
-            Eval(0445, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(0446, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(0447, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(0448, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(0449, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(0450, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(0451, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(0452, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(0453, v is ImplementAllInterface<int>, false);
-            Eval(0454, v is ImplementAllInterface<int>[], false);
-            Eval(0455, v is ImplementAllInterface<int>?, false);
-            Eval(0456, v is ImplementAllInterface<int>?[], false);
+//            Eval(0445, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(0446, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(0447, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(0448, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(0449, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(0450, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(0451, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(0452, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(0453, v is ImplementAllInterface<int>, false);
+//            Eval(0454, v is ImplementAllInterface<int>[], false);
+//            Eval(0455, v is ImplementAllInterface<int>?, false);
+//            Eval(0456, v is ImplementAllInterface<int>?[], false);
             Eval(0457, v is IntE, false);
             Eval(0458, v is IntE[], false);
             Eval(0459, v is IntE?, false);
@@ -556,38 +556,38 @@ internal class Program
             Eval(0552, v is IEmpty[], false);
             Eval(0553, v is INotEmpty, false);
             Eval(0554, v is INotEmpty[], false);
-            Eval(0555, v is IEmptyGen<int>, false);
-            Eval(0556, v is IEmptyGen<int>[], false);
-            Eval(0557, v is INotEmptyGen<int>, false);
-            Eval(0558, v is INotEmptyGen<int>[], false);
+//            Eval(0555, v is IEmptyGen<int>, false);
+//            Eval(0556, v is IEmptyGen<int>[], false);
+//            Eval(0557, v is INotEmptyGen<int>, false);
+//            Eval(0558, v is INotEmptyGen<int>[], false);
             Eval(0559, v is SimpleDelegate, false);
             Eval(0560, v is SimpleDelegate[], false);
-            Eval(0561, v is GenericDelegate<int>, false);
-            Eval(0562, v is GenericDelegate<int>[], false);
+//            Eval(0561, v is GenericDelegate<int>, false);
+//            Eval(0562, v is GenericDelegate<int>[], false);
             Eval(0563, v is EmptyClass, false);
             Eval(0564, v is EmptyClass[], false);
             Eval(0565, v is NotEmptyClass, false);
             Eval(0566, v is NotEmptyClass[], false);
-            Eval(0567, v is EmptyClassGen<int>, false);
-            Eval(0568, v is EmptyClassGen<int>[], false);
-            Eval(0569, v is NotEmptyClassGen<Guid>, false);
-            Eval(0570, v is NotEmptyClassGen<Guid>[], false);
-            Eval(0571, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(0572, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(0567, v is EmptyClassGen<int>, false);
+//            Eval(0568, v is EmptyClassGen<int>[], false);
+//            Eval(0569, v is NotEmptyClassGen<Guid>, false);
+//            Eval(0570, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(0571, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(0572, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(0573, v is NestedClass, false);
             Eval(0574, v is NestedClass[], false);
-            Eval(0575, v is NestedClassGen<Decimal>, false);
-            Eval(0576, v is NestedClassGen<Decimal>[], false);
+//            Eval(0575, v is NestedClassGen<Decimal>, false);
+//            Eval(0576, v is NestedClassGen<Decimal>[], false);
             Eval(0577, v is ImplementOneInterfaceC, false);
             Eval(0578, v is ImplementOneInterfaceC[], false);
             Eval(0579, v is ImplementTwoInterfaceC, false);
             Eval(0580, v is ImplementTwoInterfaceC[], false);
-            Eval(0581, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(0582, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(0583, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(0584, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(0585, v is ImplementAllInterfaceC<int>, false);
-            Eval(0586, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(0581, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(0582, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(0583, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(0584, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(0585, v is ImplementAllInterfaceC<int>, false);
+//            Eval(0586, v is ImplementAllInterfaceC<int>[], false);
             Eval(0587, v is SealedClass, false);
             Eval(0588, v is SealedClass[], false);
         }
@@ -601,26 +601,26 @@ internal class Program
             Eval(0594, v is NotEmptyStruct[], false);
             Eval(0595, v is NotEmptyStruct?, false);
             Eval(0596, v is NotEmptyStruct?[], false);
-            Eval(0597, v is EmptyStructGen<int>, false);
-            Eval(0598, v is EmptyStructGen<int>[], false);
-            Eval(0599, v is EmptyStructGen<int>?, false);
-            Eval(0600, v is EmptyStructGen<int>?[], false);
-            Eval(0601, v is NotEmptyStructGen<Guid>, false);
-            Eval(0602, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0603, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0604, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0605, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0606, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0607, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(0608, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0597, v is EmptyStructGen<int>, false);
+//            Eval(0598, v is EmptyStructGen<int>[], false);
+//            Eval(0599, v is EmptyStructGen<int>?, false);
+//            Eval(0600, v is EmptyStructGen<int>?[], false);
+//            Eval(0601, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0602, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0603, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0604, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0605, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0606, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0607, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(0608, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(0609, v is NestedStruct, false);
             Eval(0610, v is NestedStruct[], false);
             Eval(0611, v is NestedStruct?, false);
             Eval(0612, v is NestedStruct?[], false);
-            Eval(0613, v is NestedStructGen<Decimal>, false);
-            Eval(0614, v is NestedStructGen<Decimal>[], false);
-            Eval(0615, v is NestedStructGen<Decimal>?, false);
-            Eval(0616, v is NestedStructGen<Decimal>?[], false);
+//            Eval(0613, v is NestedStructGen<Decimal>, false);
+//            Eval(0614, v is NestedStructGen<Decimal>[], false);
+//            Eval(0615, v is NestedStructGen<Decimal>?, false);
+//            Eval(0616, v is NestedStructGen<Decimal>?[], false);
             Eval(0617, v is ExplicitFieldOffsetStruct, false);
             Eval(0618, v is ExplicitFieldOffsetStruct[], false);
             Eval(0619, v is ExplicitFieldOffsetStruct?, false);
@@ -637,18 +637,18 @@ internal class Program
             Eval(0638, v is ImplementTwoInterface[], false);
             Eval(0639, v is ImplementTwoInterface?, false);
             Eval(0640, v is ImplementTwoInterface?[], false);
-            Eval(0641, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(0642, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(0643, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(0644, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(0645, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(0646, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(0647, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(0648, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(0649, v is ImplementAllInterface<int>, false);
-            Eval(0650, v is ImplementAllInterface<int>[], false);
-            Eval(0651, v is ImplementAllInterface<int>?, false);
-            Eval(0652, v is ImplementAllInterface<int>?[], false);
+//            Eval(0641, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(0642, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(0643, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(0644, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(0645, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(0646, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(0647, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(0648, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(0649, v is ImplementAllInterface<int>, false);
+//            Eval(0650, v is ImplementAllInterface<int>[], false);
+//            Eval(0651, v is ImplementAllInterface<int>?, false);
+//            Eval(0652, v is ImplementAllInterface<int>?[], false);
             Eval(0653, v is IntE, false);
             Eval(0654, v is IntE[], false);
             Eval(0655, v is IntE?, false);
@@ -747,38 +747,38 @@ internal class Program
             Eval(0748, v is IEmpty[], false);
             Eval(0749, v is INotEmpty, false);
             Eval(0750, v is INotEmpty[], false);
-            Eval(0751, v is IEmptyGen<int>, false);
-            Eval(0752, v is IEmptyGen<int>[], false);
-            Eval(0753, v is INotEmptyGen<int>, false);
-            Eval(0754, v is INotEmptyGen<int>[], false);
+//            Eval(0751, v is IEmptyGen<int>, false);
+//            Eval(0752, v is IEmptyGen<int>[], false);
+//            Eval(0753, v is INotEmptyGen<int>, false);
+//            Eval(0754, v is INotEmptyGen<int>[], false);
             Eval(0755, v is SimpleDelegate, false);
             Eval(0756, v is SimpleDelegate[], false);
-            Eval(0757, v is GenericDelegate<int>, false);
-            Eval(0758, v is GenericDelegate<int>[], false);
+//            Eval(0757, v is GenericDelegate<int>, false);
+//            Eval(0758, v is GenericDelegate<int>[], false);
             Eval(0759, v is EmptyClass, false);
             Eval(0760, v is EmptyClass[], false);
             Eval(0761, v is NotEmptyClass, false);
             Eval(0762, v is NotEmptyClass[], false);
-            Eval(0763, v is EmptyClassGen<int>, false);
-            Eval(0764, v is EmptyClassGen<int>[], false);
-            Eval(0765, v is NotEmptyClassGen<Guid>, false);
-            Eval(0766, v is NotEmptyClassGen<Guid>[], false);
-            Eval(0767, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(0768, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(0763, v is EmptyClassGen<int>, false);
+//            Eval(0764, v is EmptyClassGen<int>[], false);
+//            Eval(0765, v is NotEmptyClassGen<Guid>, false);
+//            Eval(0766, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(0767, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(0768, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(0769, v is NestedClass, false);
             Eval(0770, v is NestedClass[], false);
-            Eval(0771, v is NestedClassGen<Decimal>, false);
-            Eval(0772, v is NestedClassGen<Decimal>[], false);
+//            Eval(0771, v is NestedClassGen<Decimal>, false);
+//            Eval(0772, v is NestedClassGen<Decimal>[], false);
             Eval(0773, v is ImplementOneInterfaceC, false);
             Eval(0774, v is ImplementOneInterfaceC[], false);
             Eval(0775, v is ImplementTwoInterfaceC, false);
             Eval(0776, v is ImplementTwoInterfaceC[], false);
-            Eval(0777, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(0778, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(0779, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(0780, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(0781, v is ImplementAllInterfaceC<int>, false);
-            Eval(0782, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(0777, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(0778, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(0779, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(0780, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(0781, v is ImplementAllInterfaceC<int>, false);
+//            Eval(0782, v is ImplementAllInterfaceC<int>[], false);
             Eval(0783, v is SealedClass, false);
             Eval(0784, v is SealedClass[], false);
         }
@@ -792,26 +792,26 @@ internal class Program
             Eval(0790, v is NotEmptyStruct[], false);
             Eval(0791, v is NotEmptyStruct?, false);
             Eval(0792, v is NotEmptyStruct?[], false);
-            Eval(0793, v is EmptyStructGen<int>, false);
-            Eval(0794, v is EmptyStructGen<int>[], false);
-            Eval(0795, v is EmptyStructGen<int>?, false);
-            Eval(0796, v is EmptyStructGen<int>?[], false);
-            Eval(0797, v is NotEmptyStructGen<Guid>, false);
-            Eval(0798, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0799, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0800, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0801, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0802, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0803, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(0804, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0793, v is EmptyStructGen<int>, false);
+//            Eval(0794, v is EmptyStructGen<int>[], false);
+//            Eval(0795, v is EmptyStructGen<int>?, false);
+//            Eval(0796, v is EmptyStructGen<int>?[], false);
+//            Eval(0797, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0798, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0799, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0800, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0801, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0802, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0803, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(0804, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(0805, v is NestedStruct, false);
             Eval(0806, v is NestedStruct[], false);
             Eval(0807, v is NestedStruct?, false);
             Eval(0808, v is NestedStruct?[], false);
-            Eval(0809, v is NestedStructGen<Decimal>, false);
-            Eval(0810, v is NestedStructGen<Decimal>[], false);
-            Eval(0811, v is NestedStructGen<Decimal>?, false);
-            Eval(0812, v is NestedStructGen<Decimal>?[], false);
+//            Eval(0809, v is NestedStructGen<Decimal>, false);
+//            Eval(0810, v is NestedStructGen<Decimal>[], false);
+//            Eval(0811, v is NestedStructGen<Decimal>?, false);
+//            Eval(0812, v is NestedStructGen<Decimal>?[], false);
             Eval(0813, v is ExplicitFieldOffsetStruct, false);
             Eval(0814, v is ExplicitFieldOffsetStruct[], false);
             Eval(0815, v is ExplicitFieldOffsetStruct?, false);
@@ -828,18 +828,18 @@ internal class Program
             Eval(0834, v is ImplementTwoInterface[], false);
             Eval(0835, v is ImplementTwoInterface?, false);
             Eval(0836, v is ImplementTwoInterface?[], false);
-            Eval(0837, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(0838, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(0839, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(0840, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(0841, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(0842, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(0843, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(0844, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(0845, v is ImplementAllInterface<int>, false);
-            Eval(0846, v is ImplementAllInterface<int>[], false);
-            Eval(0847, v is ImplementAllInterface<int>?, false);
-            Eval(0848, v is ImplementAllInterface<int>?[], false);
+//            Eval(0837, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(0838, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(0839, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(0840, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(0841, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(0842, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(0843, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(0844, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(0845, v is ImplementAllInterface<int>, false);
+//            Eval(0846, v is ImplementAllInterface<int>[], false);
+//            Eval(0847, v is ImplementAllInterface<int>?, false);
+//            Eval(0848, v is ImplementAllInterface<int>?[], false);
             Eval(0849, v is IntE, false);
             Eval(0850, v is IntE[], false);
             Eval(0851, v is IntE?, false);
@@ -938,38 +938,38 @@ internal class Program
             Eval(0944, v is IEmpty[], false);
             Eval(0945, v is INotEmpty, false);
             Eval(0946, v is INotEmpty[], false);
-            Eval(0947, v is IEmptyGen<int>, false);
-            Eval(0948, v is IEmptyGen<int>[], false);
-            Eval(0949, v is INotEmptyGen<int>, false);
-            Eval(0950, v is INotEmptyGen<int>[], false);
+//            Eval(0947, v is IEmptyGen<int>, false);
+//            Eval(0948, v is IEmptyGen<int>[], false);
+//            Eval(0949, v is INotEmptyGen<int>, false);
+//            Eval(0950, v is INotEmptyGen<int>[], false);
             Eval(0951, v is SimpleDelegate, false);
             Eval(0952, v is SimpleDelegate[], false);
-            Eval(0953, v is GenericDelegate<int>, false);
-            Eval(0954, v is GenericDelegate<int>[], false);
+//            Eval(0953, v is GenericDelegate<int>, false);
+//            Eval(0954, v is GenericDelegate<int>[], false);
             Eval(0955, v is EmptyClass, false);
             Eval(0956, v is EmptyClass[], false);
             Eval(0957, v is NotEmptyClass, false);
             Eval(0958, v is NotEmptyClass[], false);
-            Eval(0959, v is EmptyClassGen<int>, false);
-            Eval(0960, v is EmptyClassGen<int>[], false);
-            Eval(0961, v is NotEmptyClassGen<Guid>, false);
-            Eval(0962, v is NotEmptyClassGen<Guid>[], false);
-            Eval(0963, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(0964, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(0959, v is EmptyClassGen<int>, false);
+//            Eval(0960, v is EmptyClassGen<int>[], false);
+//            Eval(0961, v is NotEmptyClassGen<Guid>, false);
+//            Eval(0962, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(0963, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(0964, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(0965, v is NestedClass, false);
             Eval(0966, v is NestedClass[], false);
-            Eval(0967, v is NestedClassGen<Decimal>, false);
-            Eval(0968, v is NestedClassGen<Decimal>[], false);
+//            Eval(0967, v is NestedClassGen<Decimal>, false);
+//            Eval(0968, v is NestedClassGen<Decimal>[], false);
             Eval(0969, v is ImplementOneInterfaceC, false);
             Eval(0970, v is ImplementOneInterfaceC[], false);
             Eval(0971, v is ImplementTwoInterfaceC, false);
             Eval(0972, v is ImplementTwoInterfaceC[], false);
-            Eval(0973, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(0974, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(0975, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(0976, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(0977, v is ImplementAllInterfaceC<int>, false);
-            Eval(0978, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(0973, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(0974, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(0975, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(0976, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(0977, v is ImplementAllInterfaceC<int>, false);
+//            Eval(0978, v is ImplementAllInterfaceC<int>[], false);
             Eval(0979, v is SealedClass, false);
             Eval(0980, v is SealedClass[], false);
         }
@@ -986,26 +986,26 @@ internal class Program
             Eval(0986, v is NotEmptyStruct[], false);
             Eval(0987, v is NotEmptyStruct?, true);
             Eval(0988, v is NotEmptyStruct?[], false);
-            Eval(0989, v is EmptyStructGen<int>, false);
-            Eval(0990, v is EmptyStructGen<int>[], false);
-            Eval(0991, v is EmptyStructGen<int>?, false);
-            Eval(0992, v is EmptyStructGen<int>?[], false);
-            Eval(0993, v is NotEmptyStructGen<Guid>, false);
-            Eval(0994, v is NotEmptyStructGen<Guid>[], false);
-            Eval(0995, v is NotEmptyStructGen<Guid>?, false);
-            Eval(0996, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(0997, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(0998, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(0999, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1000, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(0989, v is EmptyStructGen<int>, false);
+//            Eval(0990, v is EmptyStructGen<int>[], false);
+//            Eval(0991, v is EmptyStructGen<int>?, false);
+//            Eval(0992, v is EmptyStructGen<int>?[], false);
+//            Eval(0993, v is NotEmptyStructGen<Guid>, false);
+//            Eval(0994, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(0995, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(0996, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(0997, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(0998, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(0999, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1000, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1001, v is NestedStruct, false);
             Eval(1002, v is NestedStruct[], false);
             Eval(1003, v is NestedStruct?, false);
             Eval(1004, v is NestedStruct?[], false);
-            Eval(1005, v is NestedStructGen<Decimal>, false);
-            Eval(1006, v is NestedStructGen<Decimal>[], false);
-            Eval(1007, v is NestedStructGen<Decimal>?, false);
-            Eval(1008, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1005, v is NestedStructGen<Decimal>, false);
+//            Eval(1006, v is NestedStructGen<Decimal>[], false);
+//            Eval(1007, v is NestedStructGen<Decimal>?, false);
+//            Eval(1008, v is NestedStructGen<Decimal>?[], false);
             Eval(1009, v is ExplicitFieldOffsetStruct, false);
             Eval(1010, v is ExplicitFieldOffsetStruct[], false);
             Eval(1011, v is ExplicitFieldOffsetStruct?, false);
@@ -1022,18 +1022,18 @@ internal class Program
             Eval(1030, v is ImplementTwoInterface[], false);
             Eval(1031, v is ImplementTwoInterface?, false);
             Eval(1032, v is ImplementTwoInterface?[], false);
-            Eval(1033, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(1034, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(1035, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(1036, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(1037, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(1038, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(1039, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(1040, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(1041, v is ImplementAllInterface<int>, false);
-            Eval(1042, v is ImplementAllInterface<int>[], false);
-            Eval(1043, v is ImplementAllInterface<int>?, false);
-            Eval(1044, v is ImplementAllInterface<int>?[], false);
+//            Eval(1033, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(1034, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(1035, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(1036, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(1037, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(1038, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(1039, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(1040, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(1041, v is ImplementAllInterface<int>, false);
+//            Eval(1042, v is ImplementAllInterface<int>[], false);
+//            Eval(1043, v is ImplementAllInterface<int>?, false);
+//            Eval(1044, v is ImplementAllInterface<int>?[], false);
             Eval(1045, v is IntE, false);
             Eval(1046, v is IntE[], false);
             Eval(1047, v is IntE?, false);
@@ -1132,38 +1132,38 @@ internal class Program
             Eval(1140, v is IEmpty[], false);
             Eval(1141, v is INotEmpty, false);
             Eval(1142, v is INotEmpty[], false);
-            Eval(1143, v is IEmptyGen<int>, false);
-            Eval(1144, v is IEmptyGen<int>[], false);
-            Eval(1145, v is INotEmptyGen<int>, false);
-            Eval(1146, v is INotEmptyGen<int>[], false);
+//            Eval(1143, v is IEmptyGen<int>, false);
+//            Eval(1144, v is IEmptyGen<int>[], false);
+//            Eval(1145, v is INotEmptyGen<int>, false);
+//            Eval(1146, v is INotEmptyGen<int>[], false);
             Eval(1147, v is SimpleDelegate, false);
             Eval(1148, v is SimpleDelegate[], false);
-            Eval(1149, v is GenericDelegate<int>, false);
-            Eval(1150, v is GenericDelegate<int>[], false);
+//            Eval(1149, v is GenericDelegate<int>, false);
+//            Eval(1150, v is GenericDelegate<int>[], false);
             Eval(1151, v is EmptyClass, false);
             Eval(1152, v is EmptyClass[], false);
             Eval(1153, v is NotEmptyClass, false);
             Eval(1154, v is NotEmptyClass[], false);
-            Eval(1155, v is EmptyClassGen<int>, false);
-            Eval(1156, v is EmptyClassGen<int>[], false);
-            Eval(1157, v is NotEmptyClassGen<Guid>, false);
-            Eval(1158, v is NotEmptyClassGen<Guid>[], false);
-            Eval(1159, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(1160, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(1155, v is EmptyClassGen<int>, false);
+//            Eval(1156, v is EmptyClassGen<int>[], false);
+//            Eval(1157, v is NotEmptyClassGen<Guid>, false);
+//            Eval(1158, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(1159, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(1160, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(1161, v is NestedClass, false);
             Eval(1162, v is NestedClass[], false);
-            Eval(1163, v is NestedClassGen<Decimal>, false);
-            Eval(1164, v is NestedClassGen<Decimal>[], false);
+//            Eval(1163, v is NestedClassGen<Decimal>, false);
+//            Eval(1164, v is NestedClassGen<Decimal>[], false);
             Eval(1165, v is ImplementOneInterfaceC, false);
             Eval(1166, v is ImplementOneInterfaceC[], false);
             Eval(1167, v is ImplementTwoInterfaceC, false);
             Eval(1168, v is ImplementTwoInterfaceC[], false);
-            Eval(1169, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(1170, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(1171, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(1172, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(1173, v is ImplementAllInterfaceC<int>, false);
-            Eval(1174, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(1169, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(1170, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(1171, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(1172, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(1173, v is ImplementAllInterfaceC<int>, false);
+//            Eval(1174, v is ImplementAllInterfaceC<int>[], false);
             Eval(1175, v is SealedClass, false);
             Eval(1176, v is SealedClass[], false);
         }
@@ -1177,26 +1177,26 @@ internal class Program
             Eval(1182, v is NotEmptyStruct[], false);
             Eval(1183, v is NotEmptyStruct?, true);
             Eval(1184, v is NotEmptyStruct?[], false);
-            Eval(1185, v is EmptyStructGen<int>, false);
-            Eval(1186, v is EmptyStructGen<int>[], false);
-            Eval(1187, v is EmptyStructGen<int>?, false);
-            Eval(1188, v is EmptyStructGen<int>?[], false);
-            Eval(1189, v is NotEmptyStructGen<Guid>, false);
-            Eval(1190, v is NotEmptyStructGen<Guid>[], false);
-            Eval(1191, v is NotEmptyStructGen<Guid>?, false);
-            Eval(1192, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(1193, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(1194, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(1195, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1196, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(1185, v is EmptyStructGen<int>, false);
+//            Eval(1186, v is EmptyStructGen<int>[], false);
+//            Eval(1187, v is EmptyStructGen<int>?, false);
+//            Eval(1188, v is EmptyStructGen<int>?[], false);
+//            Eval(1189, v is NotEmptyStructGen<Guid>, false);
+//            Eval(1190, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(1191, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(1192, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(1193, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(1194, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(1195, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1196, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1197, v is NestedStruct, false);
             Eval(1198, v is NestedStruct[], false);
             Eval(1199, v is NestedStruct?, false);
             Eval(1200, v is NestedStruct?[], false);
-            Eval(1201, v is NestedStructGen<Decimal>, false);
-            Eval(1202, v is NestedStructGen<Decimal>[], false);
-            Eval(1203, v is NestedStructGen<Decimal>?, false);
-            Eval(1204, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1201, v is NestedStructGen<Decimal>, false);
+//            Eval(1202, v is NestedStructGen<Decimal>[], false);
+//            Eval(1203, v is NestedStructGen<Decimal>?, false);
+//            Eval(1204, v is NestedStructGen<Decimal>?[], false);
             Eval(1205, v is ExplicitFieldOffsetStruct, false);
             Eval(1206, v is ExplicitFieldOffsetStruct[], false);
             Eval(1207, v is ExplicitFieldOffsetStruct?, false);
@@ -1213,18 +1213,18 @@ internal class Program
             Eval(1226, v is ImplementTwoInterface[], false);
             Eval(1227, v is ImplementTwoInterface?, false);
             Eval(1228, v is ImplementTwoInterface?[], false);
-            Eval(1229, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(1230, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(1231, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(1232, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(1233, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(1234, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(1235, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(1236, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(1237, v is ImplementAllInterface<int>, false);
-            Eval(1238, v is ImplementAllInterface<int>[], false);
-            Eval(1239, v is ImplementAllInterface<int>?, false);
-            Eval(1240, v is ImplementAllInterface<int>?[], false);
+//            Eval(1229, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(1230, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(1231, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(1232, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(1233, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(1234, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(1235, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(1236, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(1237, v is ImplementAllInterface<int>, false);
+//            Eval(1238, v is ImplementAllInterface<int>[], false);
+//            Eval(1239, v is ImplementAllInterface<int>?, false);
+//            Eval(1240, v is ImplementAllInterface<int>?[], false);
             Eval(1241, v is IntE, false);
             Eval(1242, v is IntE[], false);
             Eval(1243, v is IntE?, false);
@@ -1323,38 +1323,38 @@ internal class Program
             Eval(1336, v is IEmpty[], false);
             Eval(1337, v is INotEmpty, false);
             Eval(1338, v is INotEmpty[], false);
-            Eval(1339, v is IEmptyGen<int>, false);
-            Eval(1340, v is IEmptyGen<int>[], false);
-            Eval(1341, v is INotEmptyGen<int>, false);
-            Eval(1342, v is INotEmptyGen<int>[], false);
+//            Eval(1339, v is IEmptyGen<int>, false);
+//            Eval(1340, v is IEmptyGen<int>[], false);
+//            Eval(1341, v is INotEmptyGen<int>, false);
+//            Eval(1342, v is INotEmptyGen<int>[], false);
             Eval(1343, v is SimpleDelegate, false);
             Eval(1344, v is SimpleDelegate[], false);
-            Eval(1345, v is GenericDelegate<int>, false);
-            Eval(1346, v is GenericDelegate<int>[], false);
+//            Eval(1345, v is GenericDelegate<int>, false);
+//            Eval(1346, v is GenericDelegate<int>[], false);
             Eval(1347, v is EmptyClass, false);
             Eval(1348, v is EmptyClass[], false);
             Eval(1349, v is NotEmptyClass, false);
             Eval(1350, v is NotEmptyClass[], false);
-            Eval(1351, v is EmptyClassGen<int>, false);
-            Eval(1352, v is EmptyClassGen<int>[], false);
-            Eval(1353, v is NotEmptyClassGen<Guid>, false);
-            Eval(1354, v is NotEmptyClassGen<Guid>[], false);
-            Eval(1355, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(1356, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(1351, v is EmptyClassGen<int>, false);
+//            Eval(1352, v is EmptyClassGen<int>[], false);
+//            Eval(1353, v is NotEmptyClassGen<Guid>, false);
+//            Eval(1354, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(1355, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(1356, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(1357, v is NestedClass, false);
             Eval(1358, v is NestedClass[], false);
-            Eval(1359, v is NestedClassGen<Decimal>, false);
-            Eval(1360, v is NestedClassGen<Decimal>[], false);
+//            Eval(1359, v is NestedClassGen<Decimal>, false);
+//            Eval(1360, v is NestedClassGen<Decimal>[], false);
             Eval(1361, v is ImplementOneInterfaceC, false);
             Eval(1362, v is ImplementOneInterfaceC[], false);
             Eval(1363, v is ImplementTwoInterfaceC, false);
             Eval(1364, v is ImplementTwoInterfaceC[], false);
-            Eval(1365, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(1366, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(1367, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(1368, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(1369, v is ImplementAllInterfaceC<int>, false);
-            Eval(1370, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(1365, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(1366, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(1367, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(1368, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(1369, v is ImplementAllInterfaceC<int>, false);
+//            Eval(1370, v is ImplementAllInterfaceC<int>[], false);
             Eval(1371, v is SealedClass, false);
             Eval(1372, v is SealedClass[], false);
         }
@@ -1368,26 +1368,26 @@ internal class Program
             Eval(1378, v is NotEmptyStruct[], false);
             Eval(1379, v is NotEmptyStruct?, false);
             Eval(1380, v is NotEmptyStruct?[], false);
-            Eval(1381, v is EmptyStructGen<int>, false);
-            Eval(1382, v is EmptyStructGen<int>[], false);
-            Eval(1383, v is EmptyStructGen<int>?, false);
-            Eval(1384, v is EmptyStructGen<int>?[], false);
-            Eval(1385, v is NotEmptyStructGen<Guid>, false);
-            Eval(1386, v is NotEmptyStructGen<Guid>[], false);
-            Eval(1387, v is NotEmptyStructGen<Guid>?, false);
-            Eval(1388, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(1389, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(1390, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(1391, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1392, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(1381, v is EmptyStructGen<int>, false);
+//            Eval(1382, v is EmptyStructGen<int>[], false);
+//            Eval(1383, v is EmptyStructGen<int>?, false);
+//            Eval(1384, v is EmptyStructGen<int>?[], false);
+//            Eval(1385, v is NotEmptyStructGen<Guid>, false);
+//            Eval(1386, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(1387, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(1388, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(1389, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(1390, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(1391, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1392, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1393, v is NestedStruct, false);
             Eval(1394, v is NestedStruct[], false);
             Eval(1395, v is NestedStruct?, false);
             Eval(1396, v is NestedStruct?[], false);
-            Eval(1397, v is NestedStructGen<Decimal>, false);
-            Eval(1398, v is NestedStructGen<Decimal>[], false);
-            Eval(1399, v is NestedStructGen<Decimal>?, false);
-            Eval(1400, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1397, v is NestedStructGen<Decimal>, false);
+//            Eval(1398, v is NestedStructGen<Decimal>[], false);
+//            Eval(1399, v is NestedStructGen<Decimal>?, false);
+//            Eval(1400, v is NestedStructGen<Decimal>?[], false);
             Eval(1401, v is ExplicitFieldOffsetStruct, false);
             Eval(1402, v is ExplicitFieldOffsetStruct[], false);
             Eval(1403, v is ExplicitFieldOffsetStruct?, false);
@@ -1404,18 +1404,18 @@ internal class Program
             Eval(1422, v is ImplementTwoInterface[], false);
             Eval(1423, v is ImplementTwoInterface?, false);
             Eval(1424, v is ImplementTwoInterface?[], false);
-            Eval(1425, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(1426, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(1427, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(1428, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(1429, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(1430, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(1431, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(1432, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(1433, v is ImplementAllInterface<int>, false);
-            Eval(1434, v is ImplementAllInterface<int>[], false);
-            Eval(1435, v is ImplementAllInterface<int>?, false);
-            Eval(1436, v is ImplementAllInterface<int>?[], false);
+//            Eval(1425, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(1426, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(1427, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(1428, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(1429, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(1430, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(1431, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(1432, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(1433, v is ImplementAllInterface<int>, false);
+//            Eval(1434, v is ImplementAllInterface<int>[], false);
+//            Eval(1435, v is ImplementAllInterface<int>?, false);
+//            Eval(1436, v is ImplementAllInterface<int>?[], false);
             Eval(1437, v is IntE, false);
             Eval(1438, v is IntE[], false);
             Eval(1439, v is IntE?, false);
@@ -1514,38 +1514,38 @@ internal class Program
             Eval(1532, v is IEmpty[], false);
             Eval(1533, v is INotEmpty, false);
             Eval(1534, v is INotEmpty[], false);
-            Eval(1535, v is IEmptyGen<int>, false);
-            Eval(1536, v is IEmptyGen<int>[], false);
-            Eval(1537, v is INotEmptyGen<int>, false);
-            Eval(1538, v is INotEmptyGen<int>[], false);
+//            Eval(1535, v is IEmptyGen<int>, false);
+//            Eval(1536, v is IEmptyGen<int>[], false);
+//            Eval(1537, v is INotEmptyGen<int>, false);
+//            Eval(1538, v is INotEmptyGen<int>[], false);
             Eval(1539, v is SimpleDelegate, false);
             Eval(1540, v is SimpleDelegate[], false);
-            Eval(1541, v is GenericDelegate<int>, false);
-            Eval(1542, v is GenericDelegate<int>[], false);
+//            Eval(1541, v is GenericDelegate<int>, false);
+//            Eval(1542, v is GenericDelegate<int>[], false);
             Eval(1543, v is EmptyClass, false);
             Eval(1544, v is EmptyClass[], false);
             Eval(1545, v is NotEmptyClass, false);
             Eval(1546, v is NotEmptyClass[], false);
-            Eval(1547, v is EmptyClassGen<int>, false);
-            Eval(1548, v is EmptyClassGen<int>[], false);
-            Eval(1549, v is NotEmptyClassGen<Guid>, false);
-            Eval(1550, v is NotEmptyClassGen<Guid>[], false);
-            Eval(1551, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(1552, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(1547, v is EmptyClassGen<int>, false);
+//            Eval(1548, v is EmptyClassGen<int>[], false);
+//            Eval(1549, v is NotEmptyClassGen<Guid>, false);
+//            Eval(1550, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(1551, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(1552, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(1553, v is NestedClass, false);
             Eval(1554, v is NestedClass[], false);
-            Eval(1555, v is NestedClassGen<Decimal>, false);
-            Eval(1556, v is NestedClassGen<Decimal>[], false);
+//            Eval(1555, v is NestedClassGen<Decimal>, false);
+//            Eval(1556, v is NestedClassGen<Decimal>[], false);
             Eval(1557, v is ImplementOneInterfaceC, false);
             Eval(1558, v is ImplementOneInterfaceC[], false);
             Eval(1559, v is ImplementTwoInterfaceC, false);
             Eval(1560, v is ImplementTwoInterfaceC[], false);
-            Eval(1561, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(1562, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(1563, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(1564, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(1565, v is ImplementAllInterfaceC<int>, false);
-            Eval(1566, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(1561, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(1562, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(1563, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(1564, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(1565, v is ImplementAllInterfaceC<int>, false);
+//            Eval(1566, v is ImplementAllInterfaceC<int>[], false);
             Eval(1567, v is SealedClass, false);
             Eval(1568, v is SealedClass[], false);
         }
@@ -1559,26 +1559,26 @@ internal class Program
             Eval(1574, v is NotEmptyStruct[], false);
             Eval(1575, v is NotEmptyStruct?, false);
             Eval(1576, v is NotEmptyStruct?[], false);
-            Eval(1577, v is EmptyStructGen<int>, false);
-            Eval(1578, v is EmptyStructGen<int>[], false);
-            Eval(1579, v is EmptyStructGen<int>?, false);
-            Eval(1580, v is EmptyStructGen<int>?[], false);
-            Eval(1581, v is NotEmptyStructGen<Guid>, false);
-            Eval(1582, v is NotEmptyStructGen<Guid>[], false);
-            Eval(1583, v is NotEmptyStructGen<Guid>?, false);
-            Eval(1584, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(1585, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(1586, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(1587, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1588, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(1577, v is EmptyStructGen<int>, false);
+//            Eval(1578, v is EmptyStructGen<int>[], false);
+//            Eval(1579, v is EmptyStructGen<int>?, false);
+//            Eval(1580, v is EmptyStructGen<int>?[], false);
+//            Eval(1581, v is NotEmptyStructGen<Guid>, false);
+//            Eval(1582, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(1583, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(1584, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(1585, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(1586, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(1587, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1588, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1589, v is NestedStruct, false);
             Eval(1590, v is NestedStruct[], false);
             Eval(1591, v is NestedStruct?, false);
             Eval(1592, v is NestedStruct?[], false);
-            Eval(1593, v is NestedStructGen<Decimal>, false);
-            Eval(1594, v is NestedStructGen<Decimal>[], false);
-            Eval(1595, v is NestedStructGen<Decimal>?, false);
-            Eval(1596, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1593, v is NestedStructGen<Decimal>, false);
+//            Eval(1594, v is NestedStructGen<Decimal>[], false);
+//            Eval(1595, v is NestedStructGen<Decimal>?, false);
+//            Eval(1596, v is NestedStructGen<Decimal>?[], false);
             Eval(1597, v is ExplicitFieldOffsetStruct, false);
             Eval(1598, v is ExplicitFieldOffsetStruct[], false);
             Eval(1599, v is ExplicitFieldOffsetStruct?, false);
@@ -1595,18 +1595,18 @@ internal class Program
             Eval(1618, v is ImplementTwoInterface[], false);
             Eval(1619, v is ImplementTwoInterface?, false);
             Eval(1620, v is ImplementTwoInterface?[], false);
-            Eval(1621, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(1622, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(1623, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(1624, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(1625, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(1626, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(1627, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(1628, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(1629, v is ImplementAllInterface<int>, false);
-            Eval(1630, v is ImplementAllInterface<int>[], false);
-            Eval(1631, v is ImplementAllInterface<int>?, false);
-            Eval(1632, v is ImplementAllInterface<int>?[], false);
+//            Eval(1621, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(1622, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(1623, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(1624, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(1625, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(1626, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(1627, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(1628, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(1629, v is ImplementAllInterface<int>, false);
+//            Eval(1630, v is ImplementAllInterface<int>[], false);
+//            Eval(1631, v is ImplementAllInterface<int>?, false);
+//            Eval(1632, v is ImplementAllInterface<int>?[], false);
             Eval(1633, v is IntE, false);
             Eval(1634, v is IntE[], false);
             Eval(1635, v is IntE?, false);
@@ -1705,38 +1705,38 @@ internal class Program
             Eval(1728, v is IEmpty[], false);
             Eval(1729, v is INotEmpty, false);
             Eval(1730, v is INotEmpty[], false);
-            Eval(1731, v is IEmptyGen<int>, false);
-            Eval(1732, v is IEmptyGen<int>[], false);
-            Eval(1733, v is INotEmptyGen<int>, false);
-            Eval(1734, v is INotEmptyGen<int>[], false);
+//            Eval(1731, v is IEmptyGen<int>, false);
+//            Eval(1732, v is IEmptyGen<int>[], false);
+//            Eval(1733, v is INotEmptyGen<int>, false);
+//            Eval(1734, v is INotEmptyGen<int>[], false);
             Eval(1735, v is SimpleDelegate, false);
             Eval(1736, v is SimpleDelegate[], false);
-            Eval(1737, v is GenericDelegate<int>, false);
-            Eval(1738, v is GenericDelegate<int>[], false);
+//            Eval(1737, v is GenericDelegate<int>, false);
+//            Eval(1738, v is GenericDelegate<int>[], false);
             Eval(1739, v is EmptyClass, false);
             Eval(1740, v is EmptyClass[], false);
             Eval(1741, v is NotEmptyClass, false);
             Eval(1742, v is NotEmptyClass[], false);
-            Eval(1743, v is EmptyClassGen<int>, false);
-            Eval(1744, v is EmptyClassGen<int>[], false);
-            Eval(1745, v is NotEmptyClassGen<Guid>, false);
-            Eval(1746, v is NotEmptyClassGen<Guid>[], false);
-            Eval(1747, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(1748, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(1743, v is EmptyClassGen<int>, false);
+//            Eval(1744, v is EmptyClassGen<int>[], false);
+//            Eval(1745, v is NotEmptyClassGen<Guid>, false);
+//            Eval(1746, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(1747, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(1748, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(1749, v is NestedClass, false);
             Eval(1750, v is NestedClass[], false);
-            Eval(1751, v is NestedClassGen<Decimal>, false);
-            Eval(1752, v is NestedClassGen<Decimal>[], false);
+//            Eval(1751, v is NestedClassGen<Decimal>, false);
+//            Eval(1752, v is NestedClassGen<Decimal>[], false);
             Eval(1753, v is ImplementOneInterfaceC, false);
             Eval(1754, v is ImplementOneInterfaceC[], false);
             Eval(1755, v is ImplementTwoInterfaceC, false);
             Eval(1756, v is ImplementTwoInterfaceC[], false);
-            Eval(1757, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(1758, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(1759, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(1760, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(1761, v is ImplementAllInterfaceC<int>, false);
-            Eval(1762, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(1757, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(1758, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(1759, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(1760, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(1761, v is ImplementAllInterfaceC<int>, false);
+//            Eval(1762, v is ImplementAllInterfaceC<int>[], false);
             Eval(1763, v is SealedClass, false);
             Eval(1764, v is SealedClass[], false);
         }
@@ -1750,26 +1750,26 @@ internal class Program
             Eval(1770, v is NotEmptyStruct[], false);
             Eval(1771, v is NotEmptyStruct?, false);
             Eval(1772, v is NotEmptyStruct?[], true);
-            Eval(1773, v is EmptyStructGen<int>, false);
-            Eval(1774, v is EmptyStructGen<int>[], false);
-            Eval(1775, v is EmptyStructGen<int>?, false);
-            Eval(1776, v is EmptyStructGen<int>?[], false);
-            Eval(1777, v is NotEmptyStructGen<Guid>, false);
-            Eval(1778, v is NotEmptyStructGen<Guid>[], false);
-            Eval(1779, v is NotEmptyStructGen<Guid>?, false);
-            Eval(1780, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(1781, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(1782, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(1783, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1784, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(1773, v is EmptyStructGen<int>, false);
+//            Eval(1774, v is EmptyStructGen<int>[], false);
+//            Eval(1775, v is EmptyStructGen<int>?, false);
+//            Eval(1776, v is EmptyStructGen<int>?[], false);
+//            Eval(1777, v is NotEmptyStructGen<Guid>, false);
+//            Eval(1778, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(1779, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(1780, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(1781, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(1782, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(1783, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1784, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1785, v is NestedStruct, false);
             Eval(1786, v is NestedStruct[], false);
             Eval(1787, v is NestedStruct?, false);
             Eval(1788, v is NestedStruct?[], false);
-            Eval(1789, v is NestedStructGen<Decimal>, false);
-            Eval(1790, v is NestedStructGen<Decimal>[], false);
-            Eval(1791, v is NestedStructGen<Decimal>?, false);
-            Eval(1792, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1789, v is NestedStructGen<Decimal>, false);
+//            Eval(1790, v is NestedStructGen<Decimal>[], false);
+//            Eval(1791, v is NestedStructGen<Decimal>?, false);
+//            Eval(1792, v is NestedStructGen<Decimal>?[], false);
             Eval(1793, v is ExplicitFieldOffsetStruct, false);
             Eval(1794, v is ExplicitFieldOffsetStruct[], false);
             Eval(1795, v is ExplicitFieldOffsetStruct?, false);
@@ -1786,18 +1786,18 @@ internal class Program
             Eval(1814, v is ImplementTwoInterface[], false);
             Eval(1815, v is ImplementTwoInterface?, false);
             Eval(1816, v is ImplementTwoInterface?[], false);
-            Eval(1817, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(1818, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(1819, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(1820, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(1821, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(1822, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(1823, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(1824, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(1825, v is ImplementAllInterface<int>, false);
-            Eval(1826, v is ImplementAllInterface<int>[], false);
-            Eval(1827, v is ImplementAllInterface<int>?, false);
-            Eval(1828, v is ImplementAllInterface<int>?[], false);
+//            Eval(1817, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(1818, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(1819, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(1820, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(1821, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(1822, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(1823, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(1824, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(1825, v is ImplementAllInterface<int>, false);
+//            Eval(1826, v is ImplementAllInterface<int>[], false);
+//            Eval(1827, v is ImplementAllInterface<int>?, false);
+//            Eval(1828, v is ImplementAllInterface<int>?[], false);
             Eval(1829, v is IntE, false);
             Eval(1830, v is IntE[], false);
             Eval(1831, v is IntE?, false);
@@ -1896,38 +1896,38 @@ internal class Program
             Eval(1924, v is IEmpty[], false);
             Eval(1925, v is INotEmpty, false);
             Eval(1926, v is INotEmpty[], false);
-            Eval(1927, v is IEmptyGen<int>, false);
-            Eval(1928, v is IEmptyGen<int>[], false);
-            Eval(1929, v is INotEmptyGen<int>, false);
-            Eval(1930, v is INotEmptyGen<int>[], false);
+//            Eval(1927, v is IEmptyGen<int>, false);
+//            Eval(1928, v is IEmptyGen<int>[], false);
+//            Eval(1929, v is INotEmptyGen<int>, false);
+//            Eval(1930, v is INotEmptyGen<int>[], false);
             Eval(1931, v is SimpleDelegate, false);
             Eval(1932, v is SimpleDelegate[], false);
-            Eval(1933, v is GenericDelegate<int>, false);
-            Eval(1934, v is GenericDelegate<int>[], false);
+//            Eval(1933, v is GenericDelegate<int>, false);
+//            Eval(1934, v is GenericDelegate<int>[], false);
             Eval(1935, v is EmptyClass, false);
             Eval(1936, v is EmptyClass[], false);
             Eval(1937, v is NotEmptyClass, false);
             Eval(1938, v is NotEmptyClass[], false);
-            Eval(1939, v is EmptyClassGen<int>, false);
-            Eval(1940, v is EmptyClassGen<int>[], false);
-            Eval(1941, v is NotEmptyClassGen<Guid>, false);
-            Eval(1942, v is NotEmptyClassGen<Guid>[], false);
-            Eval(1943, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(1944, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(1939, v is EmptyClassGen<int>, false);
+//            Eval(1940, v is EmptyClassGen<int>[], false);
+//            Eval(1941, v is NotEmptyClassGen<Guid>, false);
+//            Eval(1942, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(1943, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(1944, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(1945, v is NestedClass, false);
             Eval(1946, v is NestedClass[], false);
-            Eval(1947, v is NestedClassGen<Decimal>, false);
-            Eval(1948, v is NestedClassGen<Decimal>[], false);
+//            Eval(1947, v is NestedClassGen<Decimal>, false);
+//            Eval(1948, v is NestedClassGen<Decimal>[], false);
             Eval(1949, v is ImplementOneInterfaceC, false);
             Eval(1950, v is ImplementOneInterfaceC[], false);
             Eval(1951, v is ImplementTwoInterfaceC, false);
             Eval(1952, v is ImplementTwoInterfaceC[], false);
-            Eval(1953, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(1954, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(1955, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(1956, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(1957, v is ImplementAllInterfaceC<int>, false);
-            Eval(1958, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(1953, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(1954, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(1955, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(1956, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(1957, v is ImplementAllInterfaceC<int>, false);
+//            Eval(1958, v is ImplementAllInterfaceC<int>[], false);
             Eval(1959, v is SealedClass, false);
             Eval(1960, v is SealedClass[], false);
         }
@@ -1944,26 +1944,26 @@ internal class Program
             Eval(1966, v is NotEmptyStruct[], false);
             Eval(1967, v is NotEmptyStruct?, false);
             Eval(1968, v is NotEmptyStruct?[], false);
-            Eval(1969, v is EmptyStructGen<int>, true);
-            Eval(1970, v is EmptyStructGen<int>[], false);
-            Eval(1971, v is EmptyStructGen<int>?, true);
-            Eval(1972, v is EmptyStructGen<int>?[], false);
-            Eval(1973, v is NotEmptyStructGen<Guid>, false);
-            Eval(1974, v is NotEmptyStructGen<Guid>[], false);
-            Eval(1975, v is NotEmptyStructGen<Guid>?, false);
-            Eval(1976, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(1977, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(1978, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(1979, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(1980, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(1969, v is EmptyStructGen<int>, true);
+//            Eval(1970, v is EmptyStructGen<int>[], false);
+//            Eval(1971, v is EmptyStructGen<int>?, true);
+//            Eval(1972, v is EmptyStructGen<int>?[], false);
+//            Eval(1973, v is NotEmptyStructGen<Guid>, false);
+//            Eval(1974, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(1975, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(1976, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(1977, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(1978, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(1979, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(1980, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(1981, v is NestedStruct, false);
             Eval(1982, v is NestedStruct[], false);
             Eval(1983, v is NestedStruct?, false);
             Eval(1984, v is NestedStruct?[], false);
-            Eval(1985, v is NestedStructGen<Decimal>, false);
-            Eval(1986, v is NestedStructGen<Decimal>[], false);
-            Eval(1987, v is NestedStructGen<Decimal>?, false);
-            Eval(1988, v is NestedStructGen<Decimal>?[], false);
+//            Eval(1985, v is NestedStructGen<Decimal>, false);
+//            Eval(1986, v is NestedStructGen<Decimal>[], false);
+//            Eval(1987, v is NestedStructGen<Decimal>?, false);
+//            Eval(1988, v is NestedStructGen<Decimal>?[], false);
             Eval(1989, v is ExplicitFieldOffsetStruct, false);
             Eval(1990, v is ExplicitFieldOffsetStruct[], false);
             Eval(1991, v is ExplicitFieldOffsetStruct?, false);
@@ -1980,18 +1980,18 @@ internal class Program
             Eval(2010, v is ImplementTwoInterface[], false);
             Eval(2011, v is ImplementTwoInterface?, false);
             Eval(2012, v is ImplementTwoInterface?[], false);
-            Eval(2013, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2014, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2015, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2016, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2017, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2018, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2019, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(2020, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(2021, v is ImplementAllInterface<int>, false);
-            Eval(2022, v is ImplementAllInterface<int>[], false);
-            Eval(2023, v is ImplementAllInterface<int>?, false);
-            Eval(2024, v is ImplementAllInterface<int>?[], false);
+//            Eval(2013, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2014, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2015, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2016, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2017, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2018, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2019, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(2020, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(2021, v is ImplementAllInterface<int>, false);
+//            Eval(2022, v is ImplementAllInterface<int>[], false);
+//            Eval(2023, v is ImplementAllInterface<int>?, false);
+//            Eval(2024, v is ImplementAllInterface<int>?[], false);
             Eval(2025, v is IntE, false);
             Eval(2026, v is IntE[], false);
             Eval(2027, v is IntE?, false);
@@ -2090,38 +2090,38 @@ internal class Program
             Eval(2120, v is IEmpty[], false);
             Eval(2121, v is INotEmpty, false);
             Eval(2122, v is INotEmpty[], false);
-            Eval(2123, v is IEmptyGen<int>, false);
-            Eval(2124, v is IEmptyGen<int>[], false);
-            Eval(2125, v is INotEmptyGen<int>, false);
-            Eval(2126, v is INotEmptyGen<int>[], false);
+//            Eval(2123, v is IEmptyGen<int>, false);
+//            Eval(2124, v is IEmptyGen<int>[], false);
+//            Eval(2125, v is INotEmptyGen<int>, false);
+//            Eval(2126, v is INotEmptyGen<int>[], false);
             Eval(2127, v is SimpleDelegate, false);
             Eval(2128, v is SimpleDelegate[], false);
-            Eval(2129, v is GenericDelegate<int>, false);
-            Eval(2130, v is GenericDelegate<int>[], false);
+//            Eval(2129, v is GenericDelegate<int>, false);
+//            Eval(2130, v is GenericDelegate<int>[], false);
             Eval(2131, v is EmptyClass, false);
             Eval(2132, v is EmptyClass[], false);
             Eval(2133, v is NotEmptyClass, false);
             Eval(2134, v is NotEmptyClass[], false);
-            Eval(2135, v is EmptyClassGen<int>, false);
-            Eval(2136, v is EmptyClassGen<int>[], false);
-            Eval(2137, v is NotEmptyClassGen<Guid>, false);
-            Eval(2138, v is NotEmptyClassGen<Guid>[], false);
-            Eval(2139, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(2140, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(2135, v is EmptyClassGen<int>, false);
+//            Eval(2136, v is EmptyClassGen<int>[], false);
+//            Eval(2137, v is NotEmptyClassGen<Guid>, false);
+//            Eval(2138, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(2139, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(2140, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(2141, v is NestedClass, false);
             Eval(2142, v is NestedClass[], false);
-            Eval(2143, v is NestedClassGen<Decimal>, false);
-            Eval(2144, v is NestedClassGen<Decimal>[], false);
+//            Eval(2143, v is NestedClassGen<Decimal>, false);
+//            Eval(2144, v is NestedClassGen<Decimal>[], false);
             Eval(2145, v is ImplementOneInterfaceC, false);
             Eval(2146, v is ImplementOneInterfaceC[], false);
             Eval(2147, v is ImplementTwoInterfaceC, false);
             Eval(2148, v is ImplementTwoInterfaceC[], false);
-            Eval(2149, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(2150, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(2151, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(2152, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(2153, v is ImplementAllInterfaceC<int>, false);
-            Eval(2154, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(2149, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(2150, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(2151, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(2152, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(2153, v is ImplementAllInterfaceC<int>, false);
+//            Eval(2154, v is ImplementAllInterfaceC<int>[], false);
             Eval(2155, v is SealedClass, false);
             Eval(2156, v is SealedClass[], false);
         }
@@ -2135,26 +2135,26 @@ internal class Program
             Eval(2162, v is NotEmptyStruct[], false);
             Eval(2163, v is NotEmptyStruct?, false);
             Eval(2164, v is NotEmptyStruct?[], false);
-            Eval(2165, v is EmptyStructGen<int>, true);
-            Eval(2166, v is EmptyStructGen<int>[], false);
-            Eval(2167, v is EmptyStructGen<int>?, true);
-            Eval(2168, v is EmptyStructGen<int>?[], false);
-            Eval(2169, v is NotEmptyStructGen<Guid>, false);
-            Eval(2170, v is NotEmptyStructGen<Guid>[], false);
-            Eval(2171, v is NotEmptyStructGen<Guid>?, false);
-            Eval(2172, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(2173, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(2174, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(2175, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(2176, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(2165, v is EmptyStructGen<int>, true);
+//            Eval(2166, v is EmptyStructGen<int>[], false);
+//            Eval(2167, v is EmptyStructGen<int>?, true);
+//            Eval(2168, v is EmptyStructGen<int>?[], false);
+//            Eval(2169, v is NotEmptyStructGen<Guid>, false);
+//            Eval(2170, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(2171, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(2172, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(2173, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(2174, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(2175, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(2176, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(2177, v is NestedStruct, false);
             Eval(2178, v is NestedStruct[], false);
             Eval(2179, v is NestedStruct?, false);
             Eval(2180, v is NestedStruct?[], false);
-            Eval(2181, v is NestedStructGen<Decimal>, false);
-            Eval(2182, v is NestedStructGen<Decimal>[], false);
-            Eval(2183, v is NestedStructGen<Decimal>?, false);
-            Eval(2184, v is NestedStructGen<Decimal>?[], false);
+//            Eval(2181, v is NestedStructGen<Decimal>, false);
+//            Eval(2182, v is NestedStructGen<Decimal>[], false);
+//            Eval(2183, v is NestedStructGen<Decimal>?, false);
+//            Eval(2184, v is NestedStructGen<Decimal>?[], false);
             Eval(2185, v is ExplicitFieldOffsetStruct, false);
             Eval(2186, v is ExplicitFieldOffsetStruct[], false);
             Eval(2187, v is ExplicitFieldOffsetStruct?, false);
@@ -2171,18 +2171,18 @@ internal class Program
             Eval(2206, v is ImplementTwoInterface[], false);
             Eval(2207, v is ImplementTwoInterface?, false);
             Eval(2208, v is ImplementTwoInterface?[], false);
-            Eval(2209, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2210, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2211, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2212, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2213, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2214, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2215, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(2216, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(2217, v is ImplementAllInterface<int>, false);
-            Eval(2218, v is ImplementAllInterface<int>[], false);
-            Eval(2219, v is ImplementAllInterface<int>?, false);
-            Eval(2220, v is ImplementAllInterface<int>?[], false);
+//            Eval(2209, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2210, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2211, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2212, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2213, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2214, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2215, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(2216, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(2217, v is ImplementAllInterface<int>, false);
+//            Eval(2218, v is ImplementAllInterface<int>[], false);
+//            Eval(2219, v is ImplementAllInterface<int>?, false);
+//            Eval(2220, v is ImplementAllInterface<int>?[], false);
             Eval(2221, v is IntE, false);
             Eval(2222, v is IntE[], false);
             Eval(2223, v is IntE?, false);
@@ -2281,38 +2281,38 @@ internal class Program
             Eval(2316, v is IEmpty[], false);
             Eval(2317, v is INotEmpty, false);
             Eval(2318, v is INotEmpty[], false);
-            Eval(2319, v is IEmptyGen<int>, false);
-            Eval(2320, v is IEmptyGen<int>[], false);
-            Eval(2321, v is INotEmptyGen<int>, false);
-            Eval(2322, v is INotEmptyGen<int>[], false);
+//            Eval(2319, v is IEmptyGen<int>, false);
+//            Eval(2320, v is IEmptyGen<int>[], false);
+//            Eval(2321, v is INotEmptyGen<int>, false);
+//            Eval(2322, v is INotEmptyGen<int>[], false);
             Eval(2323, v is SimpleDelegate, false);
             Eval(2324, v is SimpleDelegate[], false);
-            Eval(2325, v is GenericDelegate<int>, false);
-            Eval(2326, v is GenericDelegate<int>[], false);
+//            Eval(2325, v is GenericDelegate<int>, false);
+//            Eval(2326, v is GenericDelegate<int>[], false);
             Eval(2327, v is EmptyClass, false);
             Eval(2328, v is EmptyClass[], false);
             Eval(2329, v is NotEmptyClass, false);
             Eval(2330, v is NotEmptyClass[], false);
-            Eval(2331, v is EmptyClassGen<int>, false);
-            Eval(2332, v is EmptyClassGen<int>[], false);
-            Eval(2333, v is NotEmptyClassGen<Guid>, false);
-            Eval(2334, v is NotEmptyClassGen<Guid>[], false);
-            Eval(2335, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(2336, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(2331, v is EmptyClassGen<int>, false);
+//            Eval(2332, v is EmptyClassGen<int>[], false);
+//            Eval(2333, v is NotEmptyClassGen<Guid>, false);
+//            Eval(2334, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(2335, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(2336, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(2337, v is NestedClass, false);
             Eval(2338, v is NestedClass[], false);
-            Eval(2339, v is NestedClassGen<Decimal>, false);
-            Eval(2340, v is NestedClassGen<Decimal>[], false);
+//            Eval(2339, v is NestedClassGen<Decimal>, false);
+//            Eval(2340, v is NestedClassGen<Decimal>[], false);
             Eval(2341, v is ImplementOneInterfaceC, false);
             Eval(2342, v is ImplementOneInterfaceC[], false);
             Eval(2343, v is ImplementTwoInterfaceC, false);
             Eval(2344, v is ImplementTwoInterfaceC[], false);
-            Eval(2345, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(2346, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(2347, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(2348, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(2349, v is ImplementAllInterfaceC<int>, false);
-            Eval(2350, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(2345, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(2346, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(2347, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(2348, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(2349, v is ImplementAllInterfaceC<int>, false);
+//            Eval(2350, v is ImplementAllInterfaceC<int>[], false);
             Eval(2351, v is SealedClass, false);
             Eval(2352, v is SealedClass[], false);
         }
@@ -2326,26 +2326,26 @@ internal class Program
             Eval(2358, v is NotEmptyStruct[], false);
             Eval(2359, v is NotEmptyStruct?, false);
             Eval(2360, v is NotEmptyStruct?[], false);
-            Eval(2361, v is EmptyStructGen<int>, false);
-            Eval(2362, v is EmptyStructGen<int>[], false);
-            Eval(2363, v is EmptyStructGen<int>?, false);
-            Eval(2364, v is EmptyStructGen<int>?[], false);
-            Eval(2365, v is NotEmptyStructGen<Guid>, false);
-            Eval(2366, v is NotEmptyStructGen<Guid>[], false);
-            Eval(2367, v is NotEmptyStructGen<Guid>?, false);
-            Eval(2368, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(2369, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(2370, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(2371, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(2372, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(2361, v is EmptyStructGen<int>, false);
+//            Eval(2362, v is EmptyStructGen<int>[], false);
+//            Eval(2363, v is EmptyStructGen<int>?, false);
+//            Eval(2364, v is EmptyStructGen<int>?[], false);
+//            Eval(2365, v is NotEmptyStructGen<Guid>, false);
+//            Eval(2366, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(2367, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(2368, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(2369, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(2370, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(2371, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(2372, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(2373, v is NestedStruct, false);
             Eval(2374, v is NestedStruct[], false);
             Eval(2375, v is NestedStruct?, false);
             Eval(2376, v is NestedStruct?[], false);
-            Eval(2377, v is NestedStructGen<Decimal>, false);
-            Eval(2378, v is NestedStructGen<Decimal>[], false);
-            Eval(2379, v is NestedStructGen<Decimal>?, false);
-            Eval(2380, v is NestedStructGen<Decimal>?[], false);
+//            Eval(2377, v is NestedStructGen<Decimal>, false);
+//            Eval(2378, v is NestedStructGen<Decimal>[], false);
+//            Eval(2379, v is NestedStructGen<Decimal>?, false);
+//            Eval(2380, v is NestedStructGen<Decimal>?[], false);
             Eval(2381, v is ExplicitFieldOffsetStruct, false);
             Eval(2382, v is ExplicitFieldOffsetStruct[], false);
             Eval(2383, v is ExplicitFieldOffsetStruct?, false);
@@ -2362,18 +2362,18 @@ internal class Program
             Eval(2402, v is ImplementTwoInterface[], false);
             Eval(2403, v is ImplementTwoInterface?, false);
             Eval(2404, v is ImplementTwoInterface?[], false);
-            Eval(2405, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2406, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2407, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2408, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2409, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2410, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2411, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(2412, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(2413, v is ImplementAllInterface<int>, false);
-            Eval(2414, v is ImplementAllInterface<int>[], false);
-            Eval(2415, v is ImplementAllInterface<int>?, false);
-            Eval(2416, v is ImplementAllInterface<int>?[], false);
+//            Eval(2405, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2406, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2407, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2408, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2409, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2410, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2411, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(2412, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(2413, v is ImplementAllInterface<int>, false);
+//            Eval(2414, v is ImplementAllInterface<int>[], false);
+//            Eval(2415, v is ImplementAllInterface<int>?, false);
+//            Eval(2416, v is ImplementAllInterface<int>?[], false);
             Eval(2417, v is IntE, false);
             Eval(2418, v is IntE[], false);
             Eval(2419, v is IntE?, false);
@@ -2472,38 +2472,38 @@ internal class Program
             Eval(2512, v is IEmpty[], false);
             Eval(2513, v is INotEmpty, false);
             Eval(2514, v is INotEmpty[], false);
-            Eval(2515, v is IEmptyGen<int>, false);
-            Eval(2516, v is IEmptyGen<int>[], false);
-            Eval(2517, v is INotEmptyGen<int>, false);
-            Eval(2518, v is INotEmptyGen<int>[], false);
+//            Eval(2515, v is IEmptyGen<int>, false);
+//            Eval(2516, v is IEmptyGen<int>[], false);
+//            Eval(2517, v is INotEmptyGen<int>, false);
+//            Eval(2518, v is INotEmptyGen<int>[], false);
             Eval(2519, v is SimpleDelegate, false);
             Eval(2520, v is SimpleDelegate[], false);
-            Eval(2521, v is GenericDelegate<int>, false);
-            Eval(2522, v is GenericDelegate<int>[], false);
+//            Eval(2521, v is GenericDelegate<int>, false);
+//            Eval(2522, v is GenericDelegate<int>[], false);
             Eval(2523, v is EmptyClass, false);
             Eval(2524, v is EmptyClass[], false);
             Eval(2525, v is NotEmptyClass, false);
             Eval(2526, v is NotEmptyClass[], false);
-            Eval(2527, v is EmptyClassGen<int>, false);
-            Eval(2528, v is EmptyClassGen<int>[], false);
-            Eval(2529, v is NotEmptyClassGen<Guid>, false);
-            Eval(2530, v is NotEmptyClassGen<Guid>[], false);
-            Eval(2531, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(2532, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(2527, v is EmptyClassGen<int>, false);
+//            Eval(2528, v is EmptyClassGen<int>[], false);
+//            Eval(2529, v is NotEmptyClassGen<Guid>, false);
+//            Eval(2530, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(2531, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(2532, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(2533, v is NestedClass, false);
             Eval(2534, v is NestedClass[], false);
-            Eval(2535, v is NestedClassGen<Decimal>, false);
-            Eval(2536, v is NestedClassGen<Decimal>[], false);
+//            Eval(2535, v is NestedClassGen<Decimal>, false);
+//            Eval(2536, v is NestedClassGen<Decimal>[], false);
             Eval(2537, v is ImplementOneInterfaceC, false);
             Eval(2538, v is ImplementOneInterfaceC[], false);
             Eval(2539, v is ImplementTwoInterfaceC, false);
             Eval(2540, v is ImplementTwoInterfaceC[], false);
-            Eval(2541, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(2542, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(2543, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(2544, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(2545, v is ImplementAllInterfaceC<int>, false);
-            Eval(2546, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(2541, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(2542, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(2543, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(2544, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(2545, v is ImplementAllInterfaceC<int>, false);
+//            Eval(2546, v is ImplementAllInterfaceC<int>[], false);
             Eval(2547, v is SealedClass, false);
             Eval(2548, v is SealedClass[], false);
         }
@@ -2517,26 +2517,26 @@ internal class Program
             Eval(2554, v is NotEmptyStruct[], false);
             Eval(2555, v is NotEmptyStruct?, false);
             Eval(2556, v is NotEmptyStruct?[], false);
-            Eval(2557, v is EmptyStructGen<int>, false);
-            Eval(2558, v is EmptyStructGen<int>[], false);
-            Eval(2559, v is EmptyStructGen<int>?, false);
-            Eval(2560, v is EmptyStructGen<int>?[], false);
-            Eval(2561, v is NotEmptyStructGen<Guid>, false);
-            Eval(2562, v is NotEmptyStructGen<Guid>[], false);
-            Eval(2563, v is NotEmptyStructGen<Guid>?, false);
-            Eval(2564, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(2565, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(2566, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(2567, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(2568, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(2557, v is EmptyStructGen<int>, false);
+//            Eval(2558, v is EmptyStructGen<int>[], false);
+//            Eval(2559, v is EmptyStructGen<int>?, false);
+//            Eval(2560, v is EmptyStructGen<int>?[], false);
+//            Eval(2561, v is NotEmptyStructGen<Guid>, false);
+//            Eval(2562, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(2563, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(2564, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(2565, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(2566, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(2567, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(2568, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(2569, v is NestedStruct, false);
             Eval(2570, v is NestedStruct[], false);
             Eval(2571, v is NestedStruct?, false);
             Eval(2572, v is NestedStruct?[], false);
-            Eval(2573, v is NestedStructGen<Decimal>, false);
-            Eval(2574, v is NestedStructGen<Decimal>[], false);
-            Eval(2575, v is NestedStructGen<Decimal>?, false);
-            Eval(2576, v is NestedStructGen<Decimal>?[], false);
+//            Eval(2573, v is NestedStructGen<Decimal>, false);
+//            Eval(2574, v is NestedStructGen<Decimal>[], false);
+//            Eval(2575, v is NestedStructGen<Decimal>?, false);
+//            Eval(2576, v is NestedStructGen<Decimal>?[], false);
             Eval(2577, v is ExplicitFieldOffsetStruct, false);
             Eval(2578, v is ExplicitFieldOffsetStruct[], false);
             Eval(2579, v is ExplicitFieldOffsetStruct?, false);
@@ -2553,18 +2553,18 @@ internal class Program
             Eval(2598, v is ImplementTwoInterface[], false);
             Eval(2599, v is ImplementTwoInterface?, false);
             Eval(2600, v is ImplementTwoInterface?[], false);
-            Eval(2601, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2602, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2603, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2604, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2605, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2606, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2607, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(2608, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(2609, v is ImplementAllInterface<int>, false);
-            Eval(2610, v is ImplementAllInterface<int>[], false);
-            Eval(2611, v is ImplementAllInterface<int>?, false);
-            Eval(2612, v is ImplementAllInterface<int>?[], false);
+//            Eval(2601, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2602, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2603, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2604, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2605, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2606, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2607, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(2608, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(2609, v is ImplementAllInterface<int>, false);
+//            Eval(2610, v is ImplementAllInterface<int>[], false);
+//            Eval(2611, v is ImplementAllInterface<int>?, false);
+//            Eval(2612, v is ImplementAllInterface<int>?[], false);
             Eval(2613, v is IntE, false);
             Eval(2614, v is IntE[], false);
             Eval(2615, v is IntE?, false);
@@ -2663,38 +2663,38 @@ internal class Program
             Eval(2708, v is IEmpty[], false);
             Eval(2709, v is INotEmpty, false);
             Eval(2710, v is INotEmpty[], false);
-            Eval(2711, v is IEmptyGen<int>, false);
-            Eval(2712, v is IEmptyGen<int>[], false);
-            Eval(2713, v is INotEmptyGen<int>, false);
-            Eval(2714, v is INotEmptyGen<int>[], false);
+//            Eval(2711, v is IEmptyGen<int>, false);
+//            Eval(2712, v is IEmptyGen<int>[], false);
+//            Eval(2713, v is INotEmptyGen<int>, false);
+//            Eval(2714, v is INotEmptyGen<int>[], false);
             Eval(2715, v is SimpleDelegate, false);
             Eval(2716, v is SimpleDelegate[], false);
-            Eval(2717, v is GenericDelegate<int>, false);
-            Eval(2718, v is GenericDelegate<int>[], false);
+//            Eval(2717, v is GenericDelegate<int>, false);
+//            Eval(2718, v is GenericDelegate<int>[], false);
             Eval(2719, v is EmptyClass, false);
             Eval(2720, v is EmptyClass[], false);
             Eval(2721, v is NotEmptyClass, false);
             Eval(2722, v is NotEmptyClass[], false);
-            Eval(2723, v is EmptyClassGen<int>, false);
-            Eval(2724, v is EmptyClassGen<int>[], false);
-            Eval(2725, v is NotEmptyClassGen<Guid>, false);
-            Eval(2726, v is NotEmptyClassGen<Guid>[], false);
-            Eval(2727, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(2728, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(2723, v is EmptyClassGen<int>, false);
+//            Eval(2724, v is EmptyClassGen<int>[], false);
+//            Eval(2725, v is NotEmptyClassGen<Guid>, false);
+//            Eval(2726, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(2727, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(2728, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(2729, v is NestedClass, false);
             Eval(2730, v is NestedClass[], false);
-            Eval(2731, v is NestedClassGen<Decimal>, false);
-            Eval(2732, v is NestedClassGen<Decimal>[], false);
+//            Eval(2731, v is NestedClassGen<Decimal>, false);
+//            Eval(2732, v is NestedClassGen<Decimal>[], false);
             Eval(2733, v is ImplementOneInterfaceC, false);
             Eval(2734, v is ImplementOneInterfaceC[], false);
             Eval(2735, v is ImplementTwoInterfaceC, false);
             Eval(2736, v is ImplementTwoInterfaceC[], false);
-            Eval(2737, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(2738, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(2739, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(2740, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(2741, v is ImplementAllInterfaceC<int>, false);
-            Eval(2742, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(2737, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(2738, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(2739, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(2740, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(2741, v is ImplementAllInterfaceC<int>, false);
+//            Eval(2742, v is ImplementAllInterfaceC<int>[], false);
             Eval(2743, v is SealedClass, false);
             Eval(2744, v is SealedClass[], false);
         }
@@ -2708,26 +2708,26 @@ internal class Program
             Eval(2750, v is NotEmptyStruct[], false);
             Eval(2751, v is NotEmptyStruct?, false);
             Eval(2752, v is NotEmptyStruct?[], false);
-            Eval(2753, v is EmptyStructGen<int>, false);
-            Eval(2754, v is EmptyStructGen<int>[], false);
-            Eval(2755, v is EmptyStructGen<int>?, false);
-            Eval(2756, v is EmptyStructGen<int>?[], true);
-            Eval(2757, v is NotEmptyStructGen<Guid>, false);
-            Eval(2758, v is NotEmptyStructGen<Guid>[], false);
-            Eval(2759, v is NotEmptyStructGen<Guid>?, false);
-            Eval(2760, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(2761, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(2762, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(2763, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(2764, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(2753, v is EmptyStructGen<int>, false);
+//            Eval(2754, v is EmptyStructGen<int>[], false);
+//            Eval(2755, v is EmptyStructGen<int>?, false);
+//            Eval(2756, v is EmptyStructGen<int>?[], true);
+//            Eval(2757, v is NotEmptyStructGen<Guid>, false);
+//            Eval(2758, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(2759, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(2760, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(2761, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(2762, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(2763, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(2764, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(2765, v is NestedStruct, false);
             Eval(2766, v is NestedStruct[], false);
             Eval(2767, v is NestedStruct?, false);
             Eval(2768, v is NestedStruct?[], false);
-            Eval(2769, v is NestedStructGen<Decimal>, false);
-            Eval(2770, v is NestedStructGen<Decimal>[], false);
-            Eval(2771, v is NestedStructGen<Decimal>?, false);
-            Eval(2772, v is NestedStructGen<Decimal>?[], false);
+//            Eval(2769, v is NestedStructGen<Decimal>, false);
+//            Eval(2770, v is NestedStructGen<Decimal>[], false);
+//            Eval(2771, v is NestedStructGen<Decimal>?, false);
+//            Eval(2772, v is NestedStructGen<Decimal>?[], false);
             Eval(2773, v is ExplicitFieldOffsetStruct, false);
             Eval(2774, v is ExplicitFieldOffsetStruct[], false);
             Eval(2775, v is ExplicitFieldOffsetStruct?, false);
@@ -2744,18 +2744,18 @@ internal class Program
             Eval(2794, v is ImplementTwoInterface[], false);
             Eval(2795, v is ImplementTwoInterface?, false);
             Eval(2796, v is ImplementTwoInterface?[], false);
-            Eval(2797, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2798, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2799, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2800, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2801, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2802, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2803, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(2804, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(2805, v is ImplementAllInterface<int>, false);
-            Eval(2806, v is ImplementAllInterface<int>[], false);
-            Eval(2807, v is ImplementAllInterface<int>?, false);
-            Eval(2808, v is ImplementAllInterface<int>?[], false);
+//            Eval(2797, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2798, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2799, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2800, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2801, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2802, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2803, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(2804, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(2805, v is ImplementAllInterface<int>, false);
+//            Eval(2806, v is ImplementAllInterface<int>[], false);
+//            Eval(2807, v is ImplementAllInterface<int>?, false);
+//            Eval(2808, v is ImplementAllInterface<int>?[], false);
             Eval(2809, v is IntE, false);
             Eval(2810, v is IntE[], false);
             Eval(2811, v is IntE?, false);
@@ -2854,38 +2854,38 @@ internal class Program
             Eval(2904, v is IEmpty[], false);
             Eval(2905, v is INotEmpty, false);
             Eval(2906, v is INotEmpty[], false);
-            Eval(2907, v is IEmptyGen<int>, false);
-            Eval(2908, v is IEmptyGen<int>[], false);
-            Eval(2909, v is INotEmptyGen<int>, false);
-            Eval(2910, v is INotEmptyGen<int>[], false);
+//            Eval(2907, v is IEmptyGen<int>, false);
+//            Eval(2908, v is IEmptyGen<int>[], false);
+//            Eval(2909, v is INotEmptyGen<int>, false);
+//            Eval(2910, v is INotEmptyGen<int>[], false);
             Eval(2911, v is SimpleDelegate, false);
             Eval(2912, v is SimpleDelegate[], false);
-            Eval(2913, v is GenericDelegate<int>, false);
-            Eval(2914, v is GenericDelegate<int>[], false);
+//            Eval(2913, v is GenericDelegate<int>, false);
+//            Eval(2914, v is GenericDelegate<int>[], false);
             Eval(2915, v is EmptyClass, false);
             Eval(2916, v is EmptyClass[], false);
             Eval(2917, v is NotEmptyClass, false);
             Eval(2918, v is NotEmptyClass[], false);
-            Eval(2919, v is EmptyClassGen<int>, false);
-            Eval(2920, v is EmptyClassGen<int>[], false);
-            Eval(2921, v is NotEmptyClassGen<Guid>, false);
-            Eval(2922, v is NotEmptyClassGen<Guid>[], false);
-            Eval(2923, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(2924, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(2919, v is EmptyClassGen<int>, false);
+//            Eval(2920, v is EmptyClassGen<int>[], false);
+//            Eval(2921, v is NotEmptyClassGen<Guid>, false);
+//            Eval(2922, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(2923, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(2924, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(2925, v is NestedClass, false);
             Eval(2926, v is NestedClass[], false);
-            Eval(2927, v is NestedClassGen<Decimal>, false);
-            Eval(2928, v is NestedClassGen<Decimal>[], false);
+//            Eval(2927, v is NestedClassGen<Decimal>, false);
+//            Eval(2928, v is NestedClassGen<Decimal>[], false);
             Eval(2929, v is ImplementOneInterfaceC, false);
             Eval(2930, v is ImplementOneInterfaceC[], false);
             Eval(2931, v is ImplementTwoInterfaceC, false);
             Eval(2932, v is ImplementTwoInterfaceC[], false);
-            Eval(2933, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(2934, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(2935, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(2936, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(2937, v is ImplementAllInterfaceC<int>, false);
-            Eval(2938, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(2933, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(2934, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(2935, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(2936, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(2937, v is ImplementAllInterfaceC<int>, false);
+//            Eval(2938, v is ImplementAllInterfaceC<int>[], false);
             Eval(2939, v is SealedClass, false);
             Eval(2940, v is SealedClass[], false);
         }
@@ -2902,26 +2902,26 @@ internal class Program
             Eval(2946, v is NotEmptyStruct[], false);
             Eval(2947, v is NotEmptyStruct?, false);
             Eval(2948, v is NotEmptyStruct?[], false);
-            Eval(2949, v is EmptyStructGen<int>, false);
-            Eval(2950, v is EmptyStructGen<int>[], false);
-            Eval(2951, v is EmptyStructGen<int>?, false);
-            Eval(2952, v is EmptyStructGen<int>?[], false);
-            Eval(2953, v is NotEmptyStructGen<Guid>, true);
-            Eval(2954, v is NotEmptyStructGen<Guid>[], false);
-            Eval(2955, v is NotEmptyStructGen<Guid>?, true);
-            Eval(2956, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(2957, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(2958, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(2959, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(2960, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(2949, v is EmptyStructGen<int>, false);
+//            Eval(2950, v is EmptyStructGen<int>[], false);
+//            Eval(2951, v is EmptyStructGen<int>?, false);
+//            Eval(2952, v is EmptyStructGen<int>?[], false);
+//            Eval(2953, v is NotEmptyStructGen<Guid>, true);
+//            Eval(2954, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(2955, v is NotEmptyStructGen<Guid>?, true);
+//            Eval(2956, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(2957, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(2958, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(2959, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(2960, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(2961, v is NestedStruct, false);
             Eval(2962, v is NestedStruct[], false);
             Eval(2963, v is NestedStruct?, false);
             Eval(2964, v is NestedStruct?[], false);
-            Eval(2965, v is NestedStructGen<Decimal>, false);
-            Eval(2966, v is NestedStructGen<Decimal>[], false);
-            Eval(2967, v is NestedStructGen<Decimal>?, false);
-            Eval(2968, v is NestedStructGen<Decimal>?[], false);
+//            Eval(2965, v is NestedStructGen<Decimal>, false);
+//            Eval(2966, v is NestedStructGen<Decimal>[], false);
+//            Eval(2967, v is NestedStructGen<Decimal>?, false);
+//            Eval(2968, v is NestedStructGen<Decimal>?[], false);
             Eval(2969, v is ExplicitFieldOffsetStruct, false);
             Eval(2970, v is ExplicitFieldOffsetStruct[], false);
             Eval(2971, v is ExplicitFieldOffsetStruct?, false);
@@ -2938,18 +2938,18 @@ internal class Program
             Eval(2990, v is ImplementTwoInterface[], false);
             Eval(2991, v is ImplementTwoInterface?, false);
             Eval(2992, v is ImplementTwoInterface?[], false);
-            Eval(2993, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(2994, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(2995, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(2996, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(2997, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(2998, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(2999, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3000, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3001, v is ImplementAllInterface<int>, false);
-            Eval(3002, v is ImplementAllInterface<int>[], false);
-            Eval(3003, v is ImplementAllInterface<int>?, false);
-            Eval(3004, v is ImplementAllInterface<int>?[], false);
+//            Eval(2993, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(2994, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(2995, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(2996, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(2997, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(2998, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(2999, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3000, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3001, v is ImplementAllInterface<int>, false);
+//            Eval(3002, v is ImplementAllInterface<int>[], false);
+//            Eval(3003, v is ImplementAllInterface<int>?, false);
+//            Eval(3004, v is ImplementAllInterface<int>?[], false);
             Eval(3005, v is IntE, false);
             Eval(3006, v is IntE[], false);
             Eval(3007, v is IntE?, false);
@@ -3048,38 +3048,38 @@ internal class Program
             Eval(3100, v is IEmpty[], false);
             Eval(3101, v is INotEmpty, false);
             Eval(3102, v is INotEmpty[], false);
-            Eval(3103, v is IEmptyGen<int>, false);
-            Eval(3104, v is IEmptyGen<int>[], false);
-            Eval(3105, v is INotEmptyGen<int>, false);
-            Eval(3106, v is INotEmptyGen<int>[], false);
+//            Eval(3103, v is IEmptyGen<int>, false);
+//            Eval(3104, v is IEmptyGen<int>[], false);
+//            Eval(3105, v is INotEmptyGen<int>, false);
+//            Eval(3106, v is INotEmptyGen<int>[], false);
             Eval(3107, v is SimpleDelegate, false);
             Eval(3108, v is SimpleDelegate[], false);
-            Eval(3109, v is GenericDelegate<int>, false);
-            Eval(3110, v is GenericDelegate<int>[], false);
+//            Eval(3109, v is GenericDelegate<int>, false);
+//            Eval(3110, v is GenericDelegate<int>[], false);
             Eval(3111, v is EmptyClass, false);
             Eval(3112, v is EmptyClass[], false);
             Eval(3113, v is NotEmptyClass, false);
             Eval(3114, v is NotEmptyClass[], false);
-            Eval(3115, v is EmptyClassGen<int>, false);
-            Eval(3116, v is EmptyClassGen<int>[], false);
-            Eval(3117, v is NotEmptyClassGen<Guid>, false);
-            Eval(3118, v is NotEmptyClassGen<Guid>[], false);
-            Eval(3119, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(3120, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(3115, v is EmptyClassGen<int>, false);
+//            Eval(3116, v is EmptyClassGen<int>[], false);
+//            Eval(3117, v is NotEmptyClassGen<Guid>, false);
+//            Eval(3118, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(3119, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(3120, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(3121, v is NestedClass, false);
             Eval(3122, v is NestedClass[], false);
-            Eval(3123, v is NestedClassGen<Decimal>, false);
-            Eval(3124, v is NestedClassGen<Decimal>[], false);
+//            Eval(3123, v is NestedClassGen<Decimal>, false);
+//            Eval(3124, v is NestedClassGen<Decimal>[], false);
             Eval(3125, v is ImplementOneInterfaceC, false);
             Eval(3126, v is ImplementOneInterfaceC[], false);
             Eval(3127, v is ImplementTwoInterfaceC, false);
             Eval(3128, v is ImplementTwoInterfaceC[], false);
-            Eval(3129, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(3130, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(3131, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(3132, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(3133, v is ImplementAllInterfaceC<int>, false);
-            Eval(3134, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(3129, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(3130, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(3131, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(3132, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(3133, v is ImplementAllInterfaceC<int>, false);
+//            Eval(3134, v is ImplementAllInterfaceC<int>[], false);
             Eval(3135, v is SealedClass, false);
             Eval(3136, v is SealedClass[], false);
         }
@@ -3093,26 +3093,26 @@ internal class Program
             Eval(3142, v is NotEmptyStruct[], false);
             Eval(3143, v is NotEmptyStruct?, false);
             Eval(3144, v is NotEmptyStruct?[], false);
-            Eval(3145, v is EmptyStructGen<int>, false);
-            Eval(3146, v is EmptyStructGen<int>[], false);
-            Eval(3147, v is EmptyStructGen<int>?, false);
-            Eval(3148, v is EmptyStructGen<int>?[], false);
-            Eval(3149, v is NotEmptyStructGen<Guid>, true);
-            Eval(3150, v is NotEmptyStructGen<Guid>[], false);
-            Eval(3151, v is NotEmptyStructGen<Guid>?, true);
-            Eval(3152, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(3153, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(3154, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(3155, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(3156, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(3145, v is EmptyStructGen<int>, false);
+//            Eval(3146, v is EmptyStructGen<int>[], false);
+//            Eval(3147, v is EmptyStructGen<int>?, false);
+//            Eval(3148, v is EmptyStructGen<int>?[], false);
+//            Eval(3149, v is NotEmptyStructGen<Guid>, true);
+//            Eval(3150, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(3151, v is NotEmptyStructGen<Guid>?, true);
+//            Eval(3152, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(3153, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(3154, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(3155, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(3156, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(3157, v is NestedStruct, false);
             Eval(3158, v is NestedStruct[], false);
             Eval(3159, v is NestedStruct?, false);
             Eval(3160, v is NestedStruct?[], false);
-            Eval(3161, v is NestedStructGen<Decimal>, false);
-            Eval(3162, v is NestedStructGen<Decimal>[], false);
-            Eval(3163, v is NestedStructGen<Decimal>?, false);
-            Eval(3164, v is NestedStructGen<Decimal>?[], false);
+//            Eval(3161, v is NestedStructGen<Decimal>, false);
+//            Eval(3162, v is NestedStructGen<Decimal>[], false);
+//            Eval(3163, v is NestedStructGen<Decimal>?, false);
+//            Eval(3164, v is NestedStructGen<Decimal>?[], false);
             Eval(3165, v is ExplicitFieldOffsetStruct, false);
             Eval(3166, v is ExplicitFieldOffsetStruct[], false);
             Eval(3167, v is ExplicitFieldOffsetStruct?, false);
@@ -3129,18 +3129,18 @@ internal class Program
             Eval(3186, v is ImplementTwoInterface[], false);
             Eval(3187, v is ImplementTwoInterface?, false);
             Eval(3188, v is ImplementTwoInterface?[], false);
-            Eval(3189, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(3190, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(3191, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(3192, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(3193, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(3194, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(3195, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3196, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3197, v is ImplementAllInterface<int>, false);
-            Eval(3198, v is ImplementAllInterface<int>[], false);
-            Eval(3199, v is ImplementAllInterface<int>?, false);
-            Eval(3200, v is ImplementAllInterface<int>?[], false);
+//            Eval(3189, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(3190, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(3191, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(3192, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(3193, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(3194, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(3195, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3196, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3197, v is ImplementAllInterface<int>, false);
+//            Eval(3198, v is ImplementAllInterface<int>[], false);
+//            Eval(3199, v is ImplementAllInterface<int>?, false);
+//            Eval(3200, v is ImplementAllInterface<int>?[], false);
             Eval(3201, v is IntE, false);
             Eval(3202, v is IntE[], false);
             Eval(3203, v is IntE?, false);
@@ -3239,38 +3239,38 @@ internal class Program
             Eval(3296, v is IEmpty[], false);
             Eval(3297, v is INotEmpty, false);
             Eval(3298, v is INotEmpty[], false);
-            Eval(3299, v is IEmptyGen<int>, false);
-            Eval(3300, v is IEmptyGen<int>[], false);
-            Eval(3301, v is INotEmptyGen<int>, false);
-            Eval(3302, v is INotEmptyGen<int>[], false);
+//            Eval(3299, v is IEmptyGen<int>, false);
+//            Eval(3300, v is IEmptyGen<int>[], false);
+//            Eval(3301, v is INotEmptyGen<int>, false);
+//            Eval(3302, v is INotEmptyGen<int>[], false);
             Eval(3303, v is SimpleDelegate, false);
             Eval(3304, v is SimpleDelegate[], false);
-            Eval(3305, v is GenericDelegate<int>, false);
-            Eval(3306, v is GenericDelegate<int>[], false);
+//            Eval(3305, v is GenericDelegate<int>, false);
+//            Eval(3306, v is GenericDelegate<int>[], false);
             Eval(3307, v is EmptyClass, false);
             Eval(3308, v is EmptyClass[], false);
             Eval(3309, v is NotEmptyClass, false);
             Eval(3310, v is NotEmptyClass[], false);
-            Eval(3311, v is EmptyClassGen<int>, false);
-            Eval(3312, v is EmptyClassGen<int>[], false);
-            Eval(3313, v is NotEmptyClassGen<Guid>, false);
-            Eval(3314, v is NotEmptyClassGen<Guid>[], false);
-            Eval(3315, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(3316, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(3311, v is EmptyClassGen<int>, false);
+//            Eval(3312, v is EmptyClassGen<int>[], false);
+//            Eval(3313, v is NotEmptyClassGen<Guid>, false);
+//            Eval(3314, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(3315, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(3316, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(3317, v is NestedClass, false);
             Eval(3318, v is NestedClass[], false);
-            Eval(3319, v is NestedClassGen<Decimal>, false);
-            Eval(3320, v is NestedClassGen<Decimal>[], false);
+//            Eval(3319, v is NestedClassGen<Decimal>, false);
+//            Eval(3320, v is NestedClassGen<Decimal>[], false);
             Eval(3321, v is ImplementOneInterfaceC, false);
             Eval(3322, v is ImplementOneInterfaceC[], false);
             Eval(3323, v is ImplementTwoInterfaceC, false);
             Eval(3324, v is ImplementTwoInterfaceC[], false);
-            Eval(3325, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(3326, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(3327, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(3328, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(3329, v is ImplementAllInterfaceC<int>, false);
-            Eval(3330, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(3325, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(3326, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(3327, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(3328, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(3329, v is ImplementAllInterfaceC<int>, false);
+//            Eval(3330, v is ImplementAllInterfaceC<int>[], false);
             Eval(3331, v is SealedClass, false);
             Eval(3332, v is SealedClass[], false);
         }
@@ -3284,26 +3284,26 @@ internal class Program
             Eval(3338, v is NotEmptyStruct[], false);
             Eval(3339, v is NotEmptyStruct?, false);
             Eval(3340, v is NotEmptyStruct?[], false);
-            Eval(3341, v is EmptyStructGen<int>, false);
-            Eval(3342, v is EmptyStructGen<int>[], false);
-            Eval(3343, v is EmptyStructGen<int>?, false);
-            Eval(3344, v is EmptyStructGen<int>?[], false);
-            Eval(3345, v is NotEmptyStructGen<Guid>, false);
-            Eval(3346, v is NotEmptyStructGen<Guid>[], false);
-            Eval(3347, v is NotEmptyStructGen<Guid>?, false);
-            Eval(3348, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(3349, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(3350, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(3351, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(3352, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(3341, v is EmptyStructGen<int>, false);
+//            Eval(3342, v is EmptyStructGen<int>[], false);
+//            Eval(3343, v is EmptyStructGen<int>?, false);
+//            Eval(3344, v is EmptyStructGen<int>?[], false);
+//            Eval(3345, v is NotEmptyStructGen<Guid>, false);
+//            Eval(3346, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(3347, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(3348, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(3349, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(3350, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(3351, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(3352, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(3353, v is NestedStruct, false);
             Eval(3354, v is NestedStruct[], false);
             Eval(3355, v is NestedStruct?, false);
             Eval(3356, v is NestedStruct?[], false);
-            Eval(3357, v is NestedStructGen<Decimal>, false);
-            Eval(3358, v is NestedStructGen<Decimal>[], false);
-            Eval(3359, v is NestedStructGen<Decimal>?, false);
-            Eval(3360, v is NestedStructGen<Decimal>?[], false);
+//            Eval(3357, v is NestedStructGen<Decimal>, false);
+//            Eval(3358, v is NestedStructGen<Decimal>[], false);
+//            Eval(3359, v is NestedStructGen<Decimal>?, false);
+//            Eval(3360, v is NestedStructGen<Decimal>?[], false);
             Eval(3361, v is ExplicitFieldOffsetStruct, false);
             Eval(3362, v is ExplicitFieldOffsetStruct[], false);
             Eval(3363, v is ExplicitFieldOffsetStruct?, false);
@@ -3320,18 +3320,18 @@ internal class Program
             Eval(3382, v is ImplementTwoInterface[], false);
             Eval(3383, v is ImplementTwoInterface?, false);
             Eval(3384, v is ImplementTwoInterface?[], false);
-            Eval(3385, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(3386, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(3387, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(3388, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(3389, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(3390, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(3391, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3392, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3393, v is ImplementAllInterface<int>, false);
-            Eval(3394, v is ImplementAllInterface<int>[], false);
-            Eval(3395, v is ImplementAllInterface<int>?, false);
-            Eval(3396, v is ImplementAllInterface<int>?[], false);
+//            Eval(3385, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(3386, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(3387, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(3388, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(3389, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(3390, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(3391, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3392, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3393, v is ImplementAllInterface<int>, false);
+//            Eval(3394, v is ImplementAllInterface<int>[], false);
+//            Eval(3395, v is ImplementAllInterface<int>?, false);
+//            Eval(3396, v is ImplementAllInterface<int>?[], false);
             Eval(3397, v is IntE, false);
             Eval(3398, v is IntE[], false);
             Eval(3399, v is IntE?, false);
@@ -3430,38 +3430,38 @@ internal class Program
             Eval(3492, v is IEmpty[], false);
             Eval(3493, v is INotEmpty, false);
             Eval(3494, v is INotEmpty[], false);
-            Eval(3495, v is IEmptyGen<int>, false);
-            Eval(3496, v is IEmptyGen<int>[], false);
-            Eval(3497, v is INotEmptyGen<int>, false);
-            Eval(3498, v is INotEmptyGen<int>[], false);
+//            Eval(3495, v is IEmptyGen<int>, false);
+//            Eval(3496, v is IEmptyGen<int>[], false);
+//            Eval(3497, v is INotEmptyGen<int>, false);
+//            Eval(3498, v is INotEmptyGen<int>[], false);
             Eval(3499, v is SimpleDelegate, false);
             Eval(3500, v is SimpleDelegate[], false);
-            Eval(3501, v is GenericDelegate<int>, false);
-            Eval(3502, v is GenericDelegate<int>[], false);
+//            Eval(3501, v is GenericDelegate<int>, false);
+//            Eval(3502, v is GenericDelegate<int>[], false);
             Eval(3503, v is EmptyClass, false);
             Eval(3504, v is EmptyClass[], false);
             Eval(3505, v is NotEmptyClass, false);
             Eval(3506, v is NotEmptyClass[], false);
-            Eval(3507, v is EmptyClassGen<int>, false);
-            Eval(3508, v is EmptyClassGen<int>[], false);
-            Eval(3509, v is NotEmptyClassGen<Guid>, false);
-            Eval(3510, v is NotEmptyClassGen<Guid>[], false);
-            Eval(3511, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(3512, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(3507, v is EmptyClassGen<int>, false);
+//            Eval(3508, v is EmptyClassGen<int>[], false);
+//            Eval(3509, v is NotEmptyClassGen<Guid>, false);
+//            Eval(3510, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(3511, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(3512, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(3513, v is NestedClass, false);
             Eval(3514, v is NestedClass[], false);
-            Eval(3515, v is NestedClassGen<Decimal>, false);
-            Eval(3516, v is NestedClassGen<Decimal>[], false);
+//            Eval(3515, v is NestedClassGen<Decimal>, false);
+//            Eval(3516, v is NestedClassGen<Decimal>[], false);
             Eval(3517, v is ImplementOneInterfaceC, false);
             Eval(3518, v is ImplementOneInterfaceC[], false);
             Eval(3519, v is ImplementTwoInterfaceC, false);
             Eval(3520, v is ImplementTwoInterfaceC[], false);
-            Eval(3521, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(3522, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(3523, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(3524, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(3525, v is ImplementAllInterfaceC<int>, false);
-            Eval(3526, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(3521, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(3522, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(3523, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(3524, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(3525, v is ImplementAllInterfaceC<int>, false);
+//            Eval(3526, v is ImplementAllInterfaceC<int>[], false);
             Eval(3527, v is SealedClass, false);
             Eval(3528, v is SealedClass[], false);
         }
@@ -3475,26 +3475,26 @@ internal class Program
             Eval(3534, v is NotEmptyStruct[], false);
             Eval(3535, v is NotEmptyStruct?, false);
             Eval(3536, v is NotEmptyStruct?[], false);
-            Eval(3537, v is EmptyStructGen<int>, false);
-            Eval(3538, v is EmptyStructGen<int>[], false);
-            Eval(3539, v is EmptyStructGen<int>?, false);
-            Eval(3540, v is EmptyStructGen<int>?[], false);
-            Eval(3541, v is NotEmptyStructGen<Guid>, false);
-            Eval(3542, v is NotEmptyStructGen<Guid>[], false);
-            Eval(3543, v is NotEmptyStructGen<Guid>?, false);
-            Eval(3544, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(3545, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(3546, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(3547, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(3548, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(3537, v is EmptyStructGen<int>, false);
+//            Eval(3538, v is EmptyStructGen<int>[], false);
+//            Eval(3539, v is EmptyStructGen<int>?, false);
+//            Eval(3540, v is EmptyStructGen<int>?[], false);
+//            Eval(3541, v is NotEmptyStructGen<Guid>, false);
+//            Eval(3542, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(3543, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(3544, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(3545, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(3546, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(3547, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(3548, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(3549, v is NestedStruct, false);
             Eval(3550, v is NestedStruct[], false);
             Eval(3551, v is NestedStruct?, false);
             Eval(3552, v is NestedStruct?[], false);
-            Eval(3553, v is NestedStructGen<Decimal>, false);
-            Eval(3554, v is NestedStructGen<Decimal>[], false);
-            Eval(3555, v is NestedStructGen<Decimal>?, false);
-            Eval(3556, v is NestedStructGen<Decimal>?[], false);
+//            Eval(3553, v is NestedStructGen<Decimal>, false);
+//            Eval(3554, v is NestedStructGen<Decimal>[], false);
+//            Eval(3555, v is NestedStructGen<Decimal>?, false);
+//            Eval(3556, v is NestedStructGen<Decimal>?[], false);
             Eval(3557, v is ExplicitFieldOffsetStruct, false);
             Eval(3558, v is ExplicitFieldOffsetStruct[], false);
             Eval(3559, v is ExplicitFieldOffsetStruct?, false);
@@ -3511,18 +3511,18 @@ internal class Program
             Eval(3578, v is ImplementTwoInterface[], false);
             Eval(3579, v is ImplementTwoInterface?, false);
             Eval(3580, v is ImplementTwoInterface?[], false);
-            Eval(3581, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(3582, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(3583, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(3584, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(3585, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(3586, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(3587, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3588, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3589, v is ImplementAllInterface<int>, false);
-            Eval(3590, v is ImplementAllInterface<int>[], false);
-            Eval(3591, v is ImplementAllInterface<int>?, false);
-            Eval(3592, v is ImplementAllInterface<int>?[], false);
+//            Eval(3581, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(3582, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(3583, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(3584, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(3585, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(3586, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(3587, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3588, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3589, v is ImplementAllInterface<int>, false);
+//            Eval(3590, v is ImplementAllInterface<int>[], false);
+//            Eval(3591, v is ImplementAllInterface<int>?, false);
+//            Eval(3592, v is ImplementAllInterface<int>?[], false);
             Eval(3593, v is IntE, false);
             Eval(3594, v is IntE[], false);
             Eval(3595, v is IntE?, false);
@@ -3621,38 +3621,38 @@ internal class Program
             Eval(3688, v is IEmpty[], false);
             Eval(3689, v is INotEmpty, false);
             Eval(3690, v is INotEmpty[], false);
-            Eval(3691, v is IEmptyGen<int>, false);
-            Eval(3692, v is IEmptyGen<int>[], false);
-            Eval(3693, v is INotEmptyGen<int>, false);
-            Eval(3694, v is INotEmptyGen<int>[], false);
+//            Eval(3691, v is IEmptyGen<int>, false);
+//            Eval(3692, v is IEmptyGen<int>[], false);
+//            Eval(3693, v is INotEmptyGen<int>, false);
+//            Eval(3694, v is INotEmptyGen<int>[], false);
             Eval(3695, v is SimpleDelegate, false);
             Eval(3696, v is SimpleDelegate[], false);
-            Eval(3697, v is GenericDelegate<int>, false);
-            Eval(3698, v is GenericDelegate<int>[], false);
+//            Eval(3697, v is GenericDelegate<int>, false);
+//            Eval(3698, v is GenericDelegate<int>[], false);
             Eval(3699, v is EmptyClass, false);
             Eval(3700, v is EmptyClass[], false);
             Eval(3701, v is NotEmptyClass, false);
             Eval(3702, v is NotEmptyClass[], false);
-            Eval(3703, v is EmptyClassGen<int>, false);
-            Eval(3704, v is EmptyClassGen<int>[], false);
-            Eval(3705, v is NotEmptyClassGen<Guid>, false);
-            Eval(3706, v is NotEmptyClassGen<Guid>[], false);
-            Eval(3707, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(3708, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(3703, v is EmptyClassGen<int>, false);
+//            Eval(3704, v is EmptyClassGen<int>[], false);
+//            Eval(3705, v is NotEmptyClassGen<Guid>, false);
+//            Eval(3706, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(3707, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(3708, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(3709, v is NestedClass, false);
             Eval(3710, v is NestedClass[], false);
-            Eval(3711, v is NestedClassGen<Decimal>, false);
-            Eval(3712, v is NestedClassGen<Decimal>[], false);
+//            Eval(3711, v is NestedClassGen<Decimal>, false);
+//            Eval(3712, v is NestedClassGen<Decimal>[], false);
             Eval(3713, v is ImplementOneInterfaceC, false);
             Eval(3714, v is ImplementOneInterfaceC[], false);
             Eval(3715, v is ImplementTwoInterfaceC, false);
             Eval(3716, v is ImplementTwoInterfaceC[], false);
-            Eval(3717, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(3718, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(3719, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(3720, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(3721, v is ImplementAllInterfaceC<int>, false);
-            Eval(3722, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(3717, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(3718, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(3719, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(3720, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(3721, v is ImplementAllInterfaceC<int>, false);
+//            Eval(3722, v is ImplementAllInterfaceC<int>[], false);
             Eval(3723, v is SealedClass, false);
             Eval(3724, v is SealedClass[], false);
         }
@@ -3666,26 +3666,26 @@ internal class Program
             Eval(3730, v is NotEmptyStruct[], false);
             Eval(3731, v is NotEmptyStruct?, false);
             Eval(3732, v is NotEmptyStruct?[], false);
-            Eval(3733, v is EmptyStructGen<int>, false);
-            Eval(3734, v is EmptyStructGen<int>[], false);
-            Eval(3735, v is EmptyStructGen<int>?, false);
-            Eval(3736, v is EmptyStructGen<int>?[], false);
-            Eval(3737, v is NotEmptyStructGen<Guid>, false);
-            Eval(3738, v is NotEmptyStructGen<Guid>[], false);
-            Eval(3739, v is NotEmptyStructGen<Guid>?, false);
-            Eval(3740, v is NotEmptyStructGen<Guid>?[], true);
-            Eval(3741, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(3742, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(3743, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(3744, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(3733, v is EmptyStructGen<int>, false);
+//            Eval(3734, v is EmptyStructGen<int>[], false);
+//            Eval(3735, v is EmptyStructGen<int>?, false);
+//            Eval(3736, v is EmptyStructGen<int>?[], false);
+//            Eval(3737, v is NotEmptyStructGen<Guid>, false);
+//            Eval(3738, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(3739, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(3740, v is NotEmptyStructGen<Guid>?[], true);
+//            Eval(3741, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(3742, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(3743, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(3744, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(3745, v is NestedStruct, false);
             Eval(3746, v is NestedStruct[], false);
             Eval(3747, v is NestedStruct?, false);
             Eval(3748, v is NestedStruct?[], false);
-            Eval(3749, v is NestedStructGen<Decimal>, false);
-            Eval(3750, v is NestedStructGen<Decimal>[], false);
-            Eval(3751, v is NestedStructGen<Decimal>?, false);
-            Eval(3752, v is NestedStructGen<Decimal>?[], false);
+//            Eval(3749, v is NestedStructGen<Decimal>, false);
+//            Eval(3750, v is NestedStructGen<Decimal>[], false);
+//            Eval(3751, v is NestedStructGen<Decimal>?, false);
+//            Eval(3752, v is NestedStructGen<Decimal>?[], false);
             Eval(3753, v is ExplicitFieldOffsetStruct, false);
             Eval(3754, v is ExplicitFieldOffsetStruct[], false);
             Eval(3755, v is ExplicitFieldOffsetStruct?, false);
@@ -3702,18 +3702,18 @@ internal class Program
             Eval(3774, v is ImplementTwoInterface[], false);
             Eval(3775, v is ImplementTwoInterface?, false);
             Eval(3776, v is ImplementTwoInterface?[], false);
-            Eval(3777, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(3778, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(3779, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(3780, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(3781, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(3782, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(3783, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3784, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3785, v is ImplementAllInterface<int>, false);
-            Eval(3786, v is ImplementAllInterface<int>[], false);
-            Eval(3787, v is ImplementAllInterface<int>?, false);
-            Eval(3788, v is ImplementAllInterface<int>?[], false);
+//            Eval(3777, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(3778, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(3779, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(3780, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(3781, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(3782, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(3783, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3784, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3785, v is ImplementAllInterface<int>, false);
+//            Eval(3786, v is ImplementAllInterface<int>[], false);
+//            Eval(3787, v is ImplementAllInterface<int>?, false);
+//            Eval(3788, v is ImplementAllInterface<int>?[], false);
             Eval(3789, v is IntE, false);
             Eval(3790, v is IntE[], false);
             Eval(3791, v is IntE?, false);
@@ -3812,38 +3812,38 @@ internal class Program
             Eval(3884, v is IEmpty[], false);
             Eval(3885, v is INotEmpty, false);
             Eval(3886, v is INotEmpty[], false);
-            Eval(3887, v is IEmptyGen<int>, false);
-            Eval(3888, v is IEmptyGen<int>[], false);
-            Eval(3889, v is INotEmptyGen<int>, false);
-            Eval(3890, v is INotEmptyGen<int>[], false);
+//            Eval(3887, v is IEmptyGen<int>, false);
+//            Eval(3888, v is IEmptyGen<int>[], false);
+//            Eval(3889, v is INotEmptyGen<int>, false);
+//            Eval(3890, v is INotEmptyGen<int>[], false);
             Eval(3891, v is SimpleDelegate, false);
             Eval(3892, v is SimpleDelegate[], false);
-            Eval(3893, v is GenericDelegate<int>, false);
-            Eval(3894, v is GenericDelegate<int>[], false);
+//            Eval(3893, v is GenericDelegate<int>, false);
+//            Eval(3894, v is GenericDelegate<int>[], false);
             Eval(3895, v is EmptyClass, false);
             Eval(3896, v is EmptyClass[], false);
             Eval(3897, v is NotEmptyClass, false);
             Eval(3898, v is NotEmptyClass[], false);
-            Eval(3899, v is EmptyClassGen<int>, false);
-            Eval(3900, v is EmptyClassGen<int>[], false);
-            Eval(3901, v is NotEmptyClassGen<Guid>, false);
-            Eval(3902, v is NotEmptyClassGen<Guid>[], false);
-            Eval(3903, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(3904, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(3899, v is EmptyClassGen<int>, false);
+//            Eval(3900, v is EmptyClassGen<int>[], false);
+//            Eval(3901, v is NotEmptyClassGen<Guid>, false);
+//            Eval(3902, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(3903, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(3904, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(3905, v is NestedClass, false);
             Eval(3906, v is NestedClass[], false);
-            Eval(3907, v is NestedClassGen<Decimal>, false);
-            Eval(3908, v is NestedClassGen<Decimal>[], false);
+//            Eval(3907, v is NestedClassGen<Decimal>, false);
+//            Eval(3908, v is NestedClassGen<Decimal>[], false);
             Eval(3909, v is ImplementOneInterfaceC, false);
             Eval(3910, v is ImplementOneInterfaceC[], false);
             Eval(3911, v is ImplementTwoInterfaceC, false);
             Eval(3912, v is ImplementTwoInterfaceC[], false);
-            Eval(3913, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(3914, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(3915, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(3916, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(3917, v is ImplementAllInterfaceC<int>, false);
-            Eval(3918, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(3913, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(3914, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(3915, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(3916, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(3917, v is ImplementAllInterfaceC<int>, false);
+//            Eval(3918, v is ImplementAllInterfaceC<int>[], false);
             Eval(3919, v is SealedClass, false);
             Eval(3920, v is SealedClass[], false);
         }
@@ -3860,26 +3860,26 @@ internal class Program
             Eval(3926, v is NotEmptyStruct[], false);
             Eval(3927, v is NotEmptyStruct?, false);
             Eval(3928, v is NotEmptyStruct?[], false);
-            Eval(3929, v is EmptyStructGen<int>, false);
-            Eval(3930, v is EmptyStructGen<int>[], false);
-            Eval(3931, v is EmptyStructGen<int>?, false);
-            Eval(3932, v is EmptyStructGen<int>?[], false);
-            Eval(3933, v is NotEmptyStructGen<Guid>, false);
-            Eval(3934, v is NotEmptyStructGen<Guid>[], false);
-            Eval(3935, v is NotEmptyStructGen<Guid>?, false);
-            Eval(3936, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(3937, v is NotEmptyStructConstrainedGen<IntPtr>, true);
-            Eval(3938, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(3939, v is NotEmptyStructConstrainedGen<IntPtr>?, true);
-            Eval(3940, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(3929, v is EmptyStructGen<int>, false);
+//            Eval(3930, v is EmptyStructGen<int>[], false);
+//            Eval(3931, v is EmptyStructGen<int>?, false);
+//            Eval(3932, v is EmptyStructGen<int>?[], false);
+//            Eval(3933, v is NotEmptyStructGen<Guid>, false);
+//            Eval(3934, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(3935, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(3936, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(3937, v is NotEmptyStructConstrainedGen<IntPtr>, true);
+//            Eval(3938, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(3939, v is NotEmptyStructConstrainedGen<IntPtr>?, true);
+//            Eval(3940, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(3941, v is NestedStruct, false);
             Eval(3942, v is NestedStruct[], false);
             Eval(3943, v is NestedStruct?, false);
             Eval(3944, v is NestedStruct?[], false);
-            Eval(3945, v is NestedStructGen<Decimal>, false);
-            Eval(3946, v is NestedStructGen<Decimal>[], false);
-            Eval(3947, v is NestedStructGen<Decimal>?, false);
-            Eval(3948, v is NestedStructGen<Decimal>?[], false);
+//            Eval(3945, v is NestedStructGen<Decimal>, false);
+//            Eval(3946, v is NestedStructGen<Decimal>[], false);
+//            Eval(3947, v is NestedStructGen<Decimal>?, false);
+//            Eval(3948, v is NestedStructGen<Decimal>?[], false);
             Eval(3949, v is ExplicitFieldOffsetStruct, false);
             Eval(3950, v is ExplicitFieldOffsetStruct[], false);
             Eval(3951, v is ExplicitFieldOffsetStruct?, false);
@@ -3896,18 +3896,18 @@ internal class Program
             Eval(3970, v is ImplementTwoInterface[], false);
             Eval(3971, v is ImplementTwoInterface?, false);
             Eval(3972, v is ImplementTwoInterface?[], false);
-            Eval(3973, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(3974, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(3975, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(3976, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(3977, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(3978, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(3979, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(3980, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(3981, v is ImplementAllInterface<int>, false);
-            Eval(3982, v is ImplementAllInterface<int>[], false);
-            Eval(3983, v is ImplementAllInterface<int>?, false);
-            Eval(3984, v is ImplementAllInterface<int>?[], false);
+//            Eval(3973, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(3974, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(3975, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(3976, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(3977, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(3978, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(3979, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(3980, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(3981, v is ImplementAllInterface<int>, false);
+//            Eval(3982, v is ImplementAllInterface<int>[], false);
+//            Eval(3983, v is ImplementAllInterface<int>?, false);
+//            Eval(3984, v is ImplementAllInterface<int>?[], false);
             Eval(3985, v is IntE, false);
             Eval(3986, v is IntE[], false);
             Eval(3987, v is IntE?, false);
@@ -4006,38 +4006,38 @@ internal class Program
             Eval(4080, v is IEmpty[], false);
             Eval(4081, v is INotEmpty, false);
             Eval(4082, v is INotEmpty[], false);
-            Eval(4083, v is IEmptyGen<int>, false);
-            Eval(4084, v is IEmptyGen<int>[], false);
-            Eval(4085, v is INotEmptyGen<int>, false);
-            Eval(4086, v is INotEmptyGen<int>[], false);
+//            Eval(4083, v is IEmptyGen<int>, false);
+//            Eval(4084, v is IEmptyGen<int>[], false);
+//            Eval(4085, v is INotEmptyGen<int>, false);
+//            Eval(4086, v is INotEmptyGen<int>[], false);
             Eval(4087, v is SimpleDelegate, false);
             Eval(4088, v is SimpleDelegate[], false);
-            Eval(4089, v is GenericDelegate<int>, false);
-            Eval(4090, v is GenericDelegate<int>[], false);
+//            Eval(4089, v is GenericDelegate<int>, false);
+//            Eval(4090, v is GenericDelegate<int>[], false);
             Eval(4091, v is EmptyClass, false);
             Eval(4092, v is EmptyClass[], false);
             Eval(4093, v is NotEmptyClass, false);
             Eval(4094, v is NotEmptyClass[], false);
-            Eval(4095, v is EmptyClassGen<int>, false);
-            Eval(4096, v is EmptyClassGen<int>[], false);
-            Eval(4097, v is NotEmptyClassGen<Guid>, false);
-            Eval(4098, v is NotEmptyClassGen<Guid>[], false);
-            Eval(4099, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(4100, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(4095, v is EmptyClassGen<int>, false);
+//            Eval(4096, v is EmptyClassGen<int>[], false);
+//            Eval(4097, v is NotEmptyClassGen<Guid>, false);
+//            Eval(4098, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(4099, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(4100, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(4101, v is NestedClass, false);
             Eval(4102, v is NestedClass[], false);
-            Eval(4103, v is NestedClassGen<Decimal>, false);
-            Eval(4104, v is NestedClassGen<Decimal>[], false);
+//            Eval(4103, v is NestedClassGen<Decimal>, false);
+//            Eval(4104, v is NestedClassGen<Decimal>[], false);
             Eval(4105, v is ImplementOneInterfaceC, false);
             Eval(4106, v is ImplementOneInterfaceC[], false);
             Eval(4107, v is ImplementTwoInterfaceC, false);
             Eval(4108, v is ImplementTwoInterfaceC[], false);
-            Eval(4109, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(4110, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(4111, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(4112, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(4113, v is ImplementAllInterfaceC<int>, false);
-            Eval(4114, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(4109, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(4110, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(4111, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(4112, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(4113, v is ImplementAllInterfaceC<int>, false);
+//            Eval(4114, v is ImplementAllInterfaceC<int>[], false);
             Eval(4115, v is SealedClass, false);
             Eval(4116, v is SealedClass[], false);
         }
@@ -4051,26 +4051,26 @@ internal class Program
             Eval(4122, v is NotEmptyStruct[], false);
             Eval(4123, v is NotEmptyStruct?, false);
             Eval(4124, v is NotEmptyStruct?[], false);
-            Eval(4125, v is EmptyStructGen<int>, false);
-            Eval(4126, v is EmptyStructGen<int>[], false);
-            Eval(4127, v is EmptyStructGen<int>?, false);
-            Eval(4128, v is EmptyStructGen<int>?[], false);
-            Eval(4129, v is NotEmptyStructGen<Guid>, false);
-            Eval(4130, v is NotEmptyStructGen<Guid>[], false);
-            Eval(4131, v is NotEmptyStructGen<Guid>?, false);
-            Eval(4132, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(4133, v is NotEmptyStructConstrainedGen<IntPtr>, true);
-            Eval(4134, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(4135, v is NotEmptyStructConstrainedGen<IntPtr>?, true);
-            Eval(4136, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(4125, v is EmptyStructGen<int>, false);
+//            Eval(4126, v is EmptyStructGen<int>[], false);
+//            Eval(4127, v is EmptyStructGen<int>?, false);
+//            Eval(4128, v is EmptyStructGen<int>?[], false);
+//            Eval(4129, v is NotEmptyStructGen<Guid>, false);
+//            Eval(4130, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(4131, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(4132, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(4133, v is NotEmptyStructConstrainedGen<IntPtr>, true);
+//            Eval(4134, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(4135, v is NotEmptyStructConstrainedGen<IntPtr>?, true);
+//            Eval(4136, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(4137, v is NestedStruct, false);
             Eval(4138, v is NestedStruct[], false);
             Eval(4139, v is NestedStruct?, false);
             Eval(4140, v is NestedStruct?[], false);
-            Eval(4141, v is NestedStructGen<Decimal>, false);
-            Eval(4142, v is NestedStructGen<Decimal>[], false);
-            Eval(4143, v is NestedStructGen<Decimal>?, false);
-            Eval(4144, v is NestedStructGen<Decimal>?[], false);
+//            Eval(4141, v is NestedStructGen<Decimal>, false);
+//            Eval(4142, v is NestedStructGen<Decimal>[], false);
+//            Eval(4143, v is NestedStructGen<Decimal>?, false);
+//            Eval(4144, v is NestedStructGen<Decimal>?[], false);
             Eval(4145, v is ExplicitFieldOffsetStruct, false);
             Eval(4146, v is ExplicitFieldOffsetStruct[], false);
             Eval(4147, v is ExplicitFieldOffsetStruct?, false);
@@ -4087,18 +4087,18 @@ internal class Program
             Eval(4166, v is ImplementTwoInterface[], false);
             Eval(4167, v is ImplementTwoInterface?, false);
             Eval(4168, v is ImplementTwoInterface?[], false);
-            Eval(4169, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(4170, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(4171, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(4172, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(4173, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(4174, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(4175, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(4176, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(4177, v is ImplementAllInterface<int>, false);
-            Eval(4178, v is ImplementAllInterface<int>[], false);
-            Eval(4179, v is ImplementAllInterface<int>?, false);
-            Eval(4180, v is ImplementAllInterface<int>?[], false);
+//            Eval(4169, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(4170, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(4171, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(4172, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(4173, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(4174, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(4175, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(4176, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(4177, v is ImplementAllInterface<int>, false);
+//            Eval(4178, v is ImplementAllInterface<int>[], false);
+//            Eval(4179, v is ImplementAllInterface<int>?, false);
+//            Eval(4180, v is ImplementAllInterface<int>?[], false);
             Eval(4181, v is IntE, false);
             Eval(4182, v is IntE[], false);
             Eval(4183, v is IntE?, false);
@@ -4197,38 +4197,38 @@ internal class Program
             Eval(4276, v is IEmpty[], false);
             Eval(4277, v is INotEmpty, false);
             Eval(4278, v is INotEmpty[], false);
-            Eval(4279, v is IEmptyGen<int>, false);
-            Eval(4280, v is IEmptyGen<int>[], false);
-            Eval(4281, v is INotEmptyGen<int>, false);
-            Eval(4282, v is INotEmptyGen<int>[], false);
+//            Eval(4279, v is IEmptyGen<int>, false);
+//            Eval(4280, v is IEmptyGen<int>[], false);
+//            Eval(4281, v is INotEmptyGen<int>, false);
+//            Eval(4282, v is INotEmptyGen<int>[], false);
             Eval(4283, v is SimpleDelegate, false);
             Eval(4284, v is SimpleDelegate[], false);
-            Eval(4285, v is GenericDelegate<int>, false);
-            Eval(4286, v is GenericDelegate<int>[], false);
+//            Eval(4285, v is GenericDelegate<int>, false);
+//            Eval(4286, v is GenericDelegate<int>[], false);
             Eval(4287, v is EmptyClass, false);
             Eval(4288, v is EmptyClass[], false);
             Eval(4289, v is NotEmptyClass, false);
             Eval(4290, v is NotEmptyClass[], false);
-            Eval(4291, v is EmptyClassGen<int>, false);
-            Eval(4292, v is EmptyClassGen<int>[], false);
-            Eval(4293, v is NotEmptyClassGen<Guid>, false);
-            Eval(4294, v is NotEmptyClassGen<Guid>[], false);
-            Eval(4295, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(4296, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(4291, v is EmptyClassGen<int>, false);
+//            Eval(4292, v is EmptyClassGen<int>[], false);
+//            Eval(4293, v is NotEmptyClassGen<Guid>, false);
+//            Eval(4294, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(4295, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(4296, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(4297, v is NestedClass, false);
             Eval(4298, v is NestedClass[], false);
-            Eval(4299, v is NestedClassGen<Decimal>, false);
-            Eval(4300, v is NestedClassGen<Decimal>[], false);
+//            Eval(4299, v is NestedClassGen<Decimal>, false);
+//            Eval(4300, v is NestedClassGen<Decimal>[], false);
             Eval(4301, v is ImplementOneInterfaceC, false);
             Eval(4302, v is ImplementOneInterfaceC[], false);
             Eval(4303, v is ImplementTwoInterfaceC, false);
             Eval(4304, v is ImplementTwoInterfaceC[], false);
-            Eval(4305, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(4306, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(4307, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(4308, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(4309, v is ImplementAllInterfaceC<int>, false);
-            Eval(4310, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(4305, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(4306, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(4307, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(4308, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(4309, v is ImplementAllInterfaceC<int>, false);
+//            Eval(4310, v is ImplementAllInterfaceC<int>[], false);
             Eval(4311, v is SealedClass, false);
             Eval(4312, v is SealedClass[], false);
         }
@@ -4242,26 +4242,26 @@ internal class Program
             Eval(4318, v is NotEmptyStruct[], false);
             Eval(4319, v is NotEmptyStruct?, false);
             Eval(4320, v is NotEmptyStruct?[], false);
-            Eval(4321, v is EmptyStructGen<int>, false);
-            Eval(4322, v is EmptyStructGen<int>[], false);
-            Eval(4323, v is EmptyStructGen<int>?, false);
-            Eval(4324, v is EmptyStructGen<int>?[], false);
-            Eval(4325, v is NotEmptyStructGen<Guid>, false);
-            Eval(4326, v is NotEmptyStructGen<Guid>[], false);
-            Eval(4327, v is NotEmptyStructGen<Guid>?, false);
-            Eval(4328, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(4329, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(4330, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(4331, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(4332, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(4321, v is EmptyStructGen<int>, false);
+//            Eval(4322, v is EmptyStructGen<int>[], false);
+//            Eval(4323, v is EmptyStructGen<int>?, false);
+//            Eval(4324, v is EmptyStructGen<int>?[], false);
+//            Eval(4325, v is NotEmptyStructGen<Guid>, false);
+//            Eval(4326, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(4327, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(4328, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(4329, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(4330, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(4331, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(4332, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(4333, v is NestedStruct, false);
             Eval(4334, v is NestedStruct[], false);
             Eval(4335, v is NestedStruct?, false);
             Eval(4336, v is NestedStruct?[], false);
-            Eval(4337, v is NestedStructGen<Decimal>, false);
-            Eval(4338, v is NestedStructGen<Decimal>[], false);
-            Eval(4339, v is NestedStructGen<Decimal>?, false);
-            Eval(4340, v is NestedStructGen<Decimal>?[], false);
+//            Eval(4337, v is NestedStructGen<Decimal>, false);
+//            Eval(4338, v is NestedStructGen<Decimal>[], false);
+//            Eval(4339, v is NestedStructGen<Decimal>?, false);
+//            Eval(4340, v is NestedStructGen<Decimal>?[], false);
             Eval(4341, v is ExplicitFieldOffsetStruct, false);
             Eval(4342, v is ExplicitFieldOffsetStruct[], false);
             Eval(4343, v is ExplicitFieldOffsetStruct?, false);
@@ -4278,18 +4278,18 @@ internal class Program
             Eval(4362, v is ImplementTwoInterface[], false);
             Eval(4363, v is ImplementTwoInterface?, false);
             Eval(4364, v is ImplementTwoInterface?[], false);
-            Eval(4365, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(4366, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(4367, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(4368, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(4369, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(4370, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(4371, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(4372, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(4373, v is ImplementAllInterface<int>, false);
-            Eval(4374, v is ImplementAllInterface<int>[], false);
-            Eval(4375, v is ImplementAllInterface<int>?, false);
-            Eval(4376, v is ImplementAllInterface<int>?[], false);
+//            Eval(4365, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(4366, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(4367, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(4368, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(4369, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(4370, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(4371, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(4372, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(4373, v is ImplementAllInterface<int>, false);
+//            Eval(4374, v is ImplementAllInterface<int>[], false);
+//            Eval(4375, v is ImplementAllInterface<int>?, false);
+//            Eval(4376, v is ImplementAllInterface<int>?[], false);
             Eval(4377, v is IntE, false);
             Eval(4378, v is IntE[], false);
             Eval(4379, v is IntE?, false);
@@ -4388,38 +4388,38 @@ internal class Program
             Eval(4472, v is IEmpty[], false);
             Eval(4473, v is INotEmpty, false);
             Eval(4474, v is INotEmpty[], false);
-            Eval(4475, v is IEmptyGen<int>, false);
-            Eval(4476, v is IEmptyGen<int>[], false);
-            Eval(4477, v is INotEmptyGen<int>, false);
-            Eval(4478, v is INotEmptyGen<int>[], false);
+//            Eval(4475, v is IEmptyGen<int>, false);
+//            Eval(4476, v is IEmptyGen<int>[], false);
+//            Eval(4477, v is INotEmptyGen<int>, false);
+//            Eval(4478, v is INotEmptyGen<int>[], false);
             Eval(4479, v is SimpleDelegate, false);
             Eval(4480, v is SimpleDelegate[], false);
-            Eval(4481, v is GenericDelegate<int>, false);
-            Eval(4482, v is GenericDelegate<int>[], false);
+//            Eval(4481, v is GenericDelegate<int>, false);
+//            Eval(4482, v is GenericDelegate<int>[], false);
             Eval(4483, v is EmptyClass, false);
             Eval(4484, v is EmptyClass[], false);
             Eval(4485, v is NotEmptyClass, false);
             Eval(4486, v is NotEmptyClass[], false);
-            Eval(4487, v is EmptyClassGen<int>, false);
-            Eval(4488, v is EmptyClassGen<int>[], false);
-            Eval(4489, v is NotEmptyClassGen<Guid>, false);
-            Eval(4490, v is NotEmptyClassGen<Guid>[], false);
-            Eval(4491, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(4492, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(4487, v is EmptyClassGen<int>, false);
+//            Eval(4488, v is EmptyClassGen<int>[], false);
+//            Eval(4489, v is NotEmptyClassGen<Guid>, false);
+//            Eval(4490, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(4491, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(4492, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(4493, v is NestedClass, false);
             Eval(4494, v is NestedClass[], false);
-            Eval(4495, v is NestedClassGen<Decimal>, false);
-            Eval(4496, v is NestedClassGen<Decimal>[], false);
+//            Eval(4495, v is NestedClassGen<Decimal>, false);
+//            Eval(4496, v is NestedClassGen<Decimal>[], false);
             Eval(4497, v is ImplementOneInterfaceC, false);
             Eval(4498, v is ImplementOneInterfaceC[], false);
             Eval(4499, v is ImplementTwoInterfaceC, false);
             Eval(4500, v is ImplementTwoInterfaceC[], false);
-            Eval(4501, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(4502, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(4503, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(4504, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(4505, v is ImplementAllInterfaceC<int>, false);
-            Eval(4506, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(4501, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(4502, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(4503, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(4504, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(4505, v is ImplementAllInterfaceC<int>, false);
+//            Eval(4506, v is ImplementAllInterfaceC<int>[], false);
             Eval(4507, v is SealedClass, false);
             Eval(4508, v is SealedClass[], false);
         }
@@ -4433,26 +4433,26 @@ internal class Program
             Eval(4514, v is NotEmptyStruct[], false);
             Eval(4515, v is NotEmptyStruct?, false);
             Eval(4516, v is NotEmptyStruct?[], false);
-            Eval(4517, v is EmptyStructGen<int>, false);
-            Eval(4518, v is EmptyStructGen<int>[], false);
-            Eval(4519, v is EmptyStructGen<int>?, false);
-            Eval(4520, v is EmptyStructGen<int>?[], false);
-            Eval(4521, v is NotEmptyStructGen<Guid>, false);
-            Eval(4522, v is NotEmptyStructGen<Guid>[], false);
-            Eval(4523, v is NotEmptyStructGen<Guid>?, false);
-            Eval(4524, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(4525, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(4526, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(4527, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(4528, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(4517, v is EmptyStructGen<int>, false);
+//            Eval(4518, v is EmptyStructGen<int>[], false);
+//            Eval(4519, v is EmptyStructGen<int>?, false);
+//            Eval(4520, v is EmptyStructGen<int>?[], false);
+//            Eval(4521, v is NotEmptyStructGen<Guid>, false);
+//            Eval(4522, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(4523, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(4524, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(4525, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(4526, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(4527, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(4528, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(4529, v is NestedStruct, false);
             Eval(4530, v is NestedStruct[], false);
             Eval(4531, v is NestedStruct?, false);
             Eval(4532, v is NestedStruct?[], false);
-            Eval(4533, v is NestedStructGen<Decimal>, false);
-            Eval(4534, v is NestedStructGen<Decimal>[], false);
-            Eval(4535, v is NestedStructGen<Decimal>?, false);
-            Eval(4536, v is NestedStructGen<Decimal>?[], false);
+//            Eval(4533, v is NestedStructGen<Decimal>, false);
+//            Eval(4534, v is NestedStructGen<Decimal>[], false);
+//            Eval(4535, v is NestedStructGen<Decimal>?, false);
+//            Eval(4536, v is NestedStructGen<Decimal>?[], false);
             Eval(4537, v is ExplicitFieldOffsetStruct, false);
             Eval(4538, v is ExplicitFieldOffsetStruct[], false);
             Eval(4539, v is ExplicitFieldOffsetStruct?, false);
@@ -4469,18 +4469,18 @@ internal class Program
             Eval(4558, v is ImplementTwoInterface[], false);
             Eval(4559, v is ImplementTwoInterface?, false);
             Eval(4560, v is ImplementTwoInterface?[], false);
-            Eval(4561, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(4562, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(4563, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(4564, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(4565, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(4566, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(4567, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(4568, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(4569, v is ImplementAllInterface<int>, false);
-            Eval(4570, v is ImplementAllInterface<int>[], false);
-            Eval(4571, v is ImplementAllInterface<int>?, false);
-            Eval(4572, v is ImplementAllInterface<int>?[], false);
+//            Eval(4561, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(4562, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(4563, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(4564, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(4565, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(4566, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(4567, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(4568, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(4569, v is ImplementAllInterface<int>, false);
+//            Eval(4570, v is ImplementAllInterface<int>[], false);
+//            Eval(4571, v is ImplementAllInterface<int>?, false);
+//            Eval(4572, v is ImplementAllInterface<int>?[], false);
             Eval(4573, v is IntE, false);
             Eval(4574, v is IntE[], false);
             Eval(4575, v is IntE?, false);
@@ -4579,38 +4579,38 @@ internal class Program
             Eval(4668, v is IEmpty[], false);
             Eval(4669, v is INotEmpty, false);
             Eval(4670, v is INotEmpty[], false);
-            Eval(4671, v is IEmptyGen<int>, false);
-            Eval(4672, v is IEmptyGen<int>[], false);
-            Eval(4673, v is INotEmptyGen<int>, false);
-            Eval(4674, v is INotEmptyGen<int>[], false);
+//            Eval(4671, v is IEmptyGen<int>, false);
+//            Eval(4672, v is IEmptyGen<int>[], false);
+//            Eval(4673, v is INotEmptyGen<int>, false);
+//            Eval(4674, v is INotEmptyGen<int>[], false);
             Eval(4675, v is SimpleDelegate, false);
             Eval(4676, v is SimpleDelegate[], false);
-            Eval(4677, v is GenericDelegate<int>, false);
-            Eval(4678, v is GenericDelegate<int>[], false);
+//            Eval(4677, v is GenericDelegate<int>, false);
+//            Eval(4678, v is GenericDelegate<int>[], false);
             Eval(4679, v is EmptyClass, false);
             Eval(4680, v is EmptyClass[], false);
             Eval(4681, v is NotEmptyClass, false);
             Eval(4682, v is NotEmptyClass[], false);
-            Eval(4683, v is EmptyClassGen<int>, false);
-            Eval(4684, v is EmptyClassGen<int>[], false);
-            Eval(4685, v is NotEmptyClassGen<Guid>, false);
-            Eval(4686, v is NotEmptyClassGen<Guid>[], false);
-            Eval(4687, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(4688, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(4683, v is EmptyClassGen<int>, false);
+//            Eval(4684, v is EmptyClassGen<int>[], false);
+//            Eval(4685, v is NotEmptyClassGen<Guid>, false);
+//            Eval(4686, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(4687, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(4688, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(4689, v is NestedClass, false);
             Eval(4690, v is NestedClass[], false);
-            Eval(4691, v is NestedClassGen<Decimal>, false);
-            Eval(4692, v is NestedClassGen<Decimal>[], false);
+//            Eval(4691, v is NestedClassGen<Decimal>, false);
+//            Eval(4692, v is NestedClassGen<Decimal>[], false);
             Eval(4693, v is ImplementOneInterfaceC, false);
             Eval(4694, v is ImplementOneInterfaceC[], false);
             Eval(4695, v is ImplementTwoInterfaceC, false);
             Eval(4696, v is ImplementTwoInterfaceC[], false);
-            Eval(4697, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(4698, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(4699, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(4700, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(4701, v is ImplementAllInterfaceC<int>, false);
-            Eval(4702, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(4697, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(4698, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(4699, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(4700, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(4701, v is ImplementAllInterfaceC<int>, false);
+//            Eval(4702, v is ImplementAllInterfaceC<int>[], false);
             Eval(4703, v is SealedClass, false);
             Eval(4704, v is SealedClass[], false);
         }
@@ -4624,26 +4624,26 @@ internal class Program
             Eval(4710, v is NotEmptyStruct[], false);
             Eval(4711, v is NotEmptyStruct?, false);
             Eval(4712, v is NotEmptyStruct?[], false);
-            Eval(4713, v is EmptyStructGen<int>, false);
-            Eval(4714, v is EmptyStructGen<int>[], false);
-            Eval(4715, v is EmptyStructGen<int>?, false);
-            Eval(4716, v is EmptyStructGen<int>?[], false);
-            Eval(4717, v is NotEmptyStructGen<Guid>, false);
-            Eval(4718, v is NotEmptyStructGen<Guid>[], false);
-            Eval(4719, v is NotEmptyStructGen<Guid>?, false);
-            Eval(4720, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(4721, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(4722, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(4723, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(4724, v is NotEmptyStructConstrainedGen<IntPtr>?[], true);
+//            Eval(4713, v is EmptyStructGen<int>, false);
+//            Eval(4714, v is EmptyStructGen<int>[], false);
+//            Eval(4715, v is EmptyStructGen<int>?, false);
+//            Eval(4716, v is EmptyStructGen<int>?[], false);
+//            Eval(4717, v is NotEmptyStructGen<Guid>, false);
+//            Eval(4718, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(4719, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(4720, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(4721, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(4722, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(4723, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(4724, v is NotEmptyStructConstrainedGen<IntPtr>?[], true);
             Eval(4725, v is NestedStruct, false);
             Eval(4726, v is NestedStruct[], false);
             Eval(4727, v is NestedStruct?, false);
             Eval(4728, v is NestedStruct?[], false);
-            Eval(4729, v is NestedStructGen<Decimal>, false);
-            Eval(4730, v is NestedStructGen<Decimal>[], false);
-            Eval(4731, v is NestedStructGen<Decimal>?, false);
-            Eval(4732, v is NestedStructGen<Decimal>?[], false);
+//            Eval(4729, v is NestedStructGen<Decimal>, false);
+//            Eval(4730, v is NestedStructGen<Decimal>[], false);
+//            Eval(4731, v is NestedStructGen<Decimal>?, false);
+//            Eval(4732, v is NestedStructGen<Decimal>?[], false);
             Eval(4733, v is ExplicitFieldOffsetStruct, false);
             Eval(4734, v is ExplicitFieldOffsetStruct[], false);
             Eval(4735, v is ExplicitFieldOffsetStruct?, false);
@@ -4660,18 +4660,18 @@ internal class Program
             Eval(4754, v is ImplementTwoInterface[], false);
             Eval(4755, v is ImplementTwoInterface?, false);
             Eval(4756, v is ImplementTwoInterface?[], false);
-            Eval(4757, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(4758, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(4759, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(4760, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(4761, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(4762, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(4763, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(4764, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(4765, v is ImplementAllInterface<int>, false);
-            Eval(4766, v is ImplementAllInterface<int>[], false);
-            Eval(4767, v is ImplementAllInterface<int>?, false);
-            Eval(4768, v is ImplementAllInterface<int>?[], false);
+//            Eval(4757, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(4758, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(4759, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(4760, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(4761, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(4762, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(4763, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(4764, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(4765, v is ImplementAllInterface<int>, false);
+//            Eval(4766, v is ImplementAllInterface<int>[], false);
+//            Eval(4767, v is ImplementAllInterface<int>?, false);
+//            Eval(4768, v is ImplementAllInterface<int>?[], false);
             Eval(4769, v is IntE, false);
             Eval(4770, v is IntE[], false);
             Eval(4771, v is IntE?, false);
@@ -4770,38 +4770,38 @@ internal class Program
             Eval(4864, v is IEmpty[], false);
             Eval(4865, v is INotEmpty, false);
             Eval(4866, v is INotEmpty[], false);
-            Eval(4867, v is IEmptyGen<int>, false);
-            Eval(4868, v is IEmptyGen<int>[], false);
-            Eval(4869, v is INotEmptyGen<int>, false);
-            Eval(4870, v is INotEmptyGen<int>[], false);
+//            Eval(4867, v is IEmptyGen<int>, false);
+//            Eval(4868, v is IEmptyGen<int>[], false);
+//            Eval(4869, v is INotEmptyGen<int>, false);
+//            Eval(4870, v is INotEmptyGen<int>[], false);
             Eval(4871, v is SimpleDelegate, false);
             Eval(4872, v is SimpleDelegate[], false);
-            Eval(4873, v is GenericDelegate<int>, false);
-            Eval(4874, v is GenericDelegate<int>[], false);
+//            Eval(4873, v is GenericDelegate<int>, false);
+//            Eval(4874, v is GenericDelegate<int>[], false);
             Eval(4875, v is EmptyClass, false);
             Eval(4876, v is EmptyClass[], false);
             Eval(4877, v is NotEmptyClass, false);
             Eval(4878, v is NotEmptyClass[], false);
-            Eval(4879, v is EmptyClassGen<int>, false);
-            Eval(4880, v is EmptyClassGen<int>[], false);
-            Eval(4881, v is NotEmptyClassGen<Guid>, false);
-            Eval(4882, v is NotEmptyClassGen<Guid>[], false);
-            Eval(4883, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(4884, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(4879, v is EmptyClassGen<int>, false);
+//            Eval(4880, v is EmptyClassGen<int>[], false);
+//            Eval(4881, v is NotEmptyClassGen<Guid>, false);
+//            Eval(4882, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(4883, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(4884, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(4885, v is NestedClass, false);
             Eval(4886, v is NestedClass[], false);
-            Eval(4887, v is NestedClassGen<Decimal>, false);
-            Eval(4888, v is NestedClassGen<Decimal>[], false);
+//            Eval(4887, v is NestedClassGen<Decimal>, false);
+//            Eval(4888, v is NestedClassGen<Decimal>[], false);
             Eval(4889, v is ImplementOneInterfaceC, false);
             Eval(4890, v is ImplementOneInterfaceC[], false);
             Eval(4891, v is ImplementTwoInterfaceC, false);
             Eval(4892, v is ImplementTwoInterfaceC[], false);
-            Eval(4893, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(4894, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(4895, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(4896, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(4897, v is ImplementAllInterfaceC<int>, false);
-            Eval(4898, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(4893, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(4894, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(4895, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(4896, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(4897, v is ImplementAllInterfaceC<int>, false);
+//            Eval(4898, v is ImplementAllInterfaceC<int>[], false);
             Eval(4899, v is SealedClass, false);
             Eval(4900, v is SealedClass[], false);
         }
@@ -4818,26 +4818,26 @@ internal class Program
             Eval(4906, v is NotEmptyStruct[], false);
             Eval(4907, v is NotEmptyStruct?, false);
             Eval(4908, v is NotEmptyStruct?[], false);
-            Eval(4909, v is EmptyStructGen<int>, false);
-            Eval(4910, v is EmptyStructGen<int>[], false);
-            Eval(4911, v is EmptyStructGen<int>?, false);
-            Eval(4912, v is EmptyStructGen<int>?[], false);
-            Eval(4913, v is NotEmptyStructGen<Guid>, false);
-            Eval(4914, v is NotEmptyStructGen<Guid>[], false);
-            Eval(4915, v is NotEmptyStructGen<Guid>?, false);
-            Eval(4916, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(4917, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(4918, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(4919, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(4920, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(4909, v is EmptyStructGen<int>, false);
+//            Eval(4910, v is EmptyStructGen<int>[], false);
+//            Eval(4911, v is EmptyStructGen<int>?, false);
+//            Eval(4912, v is EmptyStructGen<int>?[], false);
+//            Eval(4913, v is NotEmptyStructGen<Guid>, false);
+//            Eval(4914, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(4915, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(4916, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(4917, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(4918, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(4919, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(4920, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(4921, v is NestedStruct, true);
             Eval(4922, v is NestedStruct[], false);
             Eval(4923, v is NestedStruct?, true);
             Eval(4924, v is NestedStruct?[], false);
-            Eval(4925, v is NestedStructGen<Decimal>, false);
-            Eval(4926, v is NestedStructGen<Decimal>[], false);
-            Eval(4927, v is NestedStructGen<Decimal>?, false);
-            Eval(4928, v is NestedStructGen<Decimal>?[], false);
+//            Eval(4925, v is NestedStructGen<Decimal>, false);
+//            Eval(4926, v is NestedStructGen<Decimal>[], false);
+//            Eval(4927, v is NestedStructGen<Decimal>?, false);
+//            Eval(4928, v is NestedStructGen<Decimal>?[], false);
             Eval(4929, v is ExplicitFieldOffsetStruct, false);
             Eval(4930, v is ExplicitFieldOffsetStruct[], false);
             Eval(4931, v is ExplicitFieldOffsetStruct?, false);
@@ -4854,18 +4854,18 @@ internal class Program
             Eval(4950, v is ImplementTwoInterface[], false);
             Eval(4951, v is ImplementTwoInterface?, false);
             Eval(4952, v is ImplementTwoInterface?[], false);
-            Eval(4953, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(4954, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(4955, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(4956, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(4957, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(4958, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(4959, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(4960, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(4961, v is ImplementAllInterface<int>, false);
-            Eval(4962, v is ImplementAllInterface<int>[], false);
-            Eval(4963, v is ImplementAllInterface<int>?, false);
-            Eval(4964, v is ImplementAllInterface<int>?[], false);
+//            Eval(4953, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(4954, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(4955, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(4956, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(4957, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(4958, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(4959, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(4960, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(4961, v is ImplementAllInterface<int>, false);
+//            Eval(4962, v is ImplementAllInterface<int>[], false);
+//            Eval(4963, v is ImplementAllInterface<int>?, false);
+//            Eval(4964, v is ImplementAllInterface<int>?[], false);
             Eval(4965, v is IntE, false);
             Eval(4966, v is IntE[], false);
             Eval(4967, v is IntE?, false);
@@ -4964,38 +4964,38 @@ internal class Program
             Eval(5060, v is IEmpty[], false);
             Eval(5061, v is INotEmpty, false);
             Eval(5062, v is INotEmpty[], false);
-            Eval(5063, v is IEmptyGen<int>, false);
-            Eval(5064, v is IEmptyGen<int>[], false);
-            Eval(5065, v is INotEmptyGen<int>, false);
-            Eval(5066, v is INotEmptyGen<int>[], false);
+//            Eval(5063, v is IEmptyGen<int>, false);
+//            Eval(5064, v is IEmptyGen<int>[], false);
+//            Eval(5065, v is INotEmptyGen<int>, false);
+//            Eval(5066, v is INotEmptyGen<int>[], false);
             Eval(5067, v is SimpleDelegate, false);
             Eval(5068, v is SimpleDelegate[], false);
-            Eval(5069, v is GenericDelegate<int>, false);
-            Eval(5070, v is GenericDelegate<int>[], false);
+//            Eval(5069, v is GenericDelegate<int>, false);
+//            Eval(5070, v is GenericDelegate<int>[], false);
             Eval(5071, v is EmptyClass, false);
             Eval(5072, v is EmptyClass[], false);
             Eval(5073, v is NotEmptyClass, false);
             Eval(5074, v is NotEmptyClass[], false);
-            Eval(5075, v is EmptyClassGen<int>, false);
-            Eval(5076, v is EmptyClassGen<int>[], false);
-            Eval(5077, v is NotEmptyClassGen<Guid>, false);
-            Eval(5078, v is NotEmptyClassGen<Guid>[], false);
-            Eval(5079, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(5080, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(5075, v is EmptyClassGen<int>, false);
+//            Eval(5076, v is EmptyClassGen<int>[], false);
+//            Eval(5077, v is NotEmptyClassGen<Guid>, false);
+//            Eval(5078, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(5079, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(5080, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(5081, v is NestedClass, false);
             Eval(5082, v is NestedClass[], false);
-            Eval(5083, v is NestedClassGen<Decimal>, false);
-            Eval(5084, v is NestedClassGen<Decimal>[], false);
+//            Eval(5083, v is NestedClassGen<Decimal>, false);
+//            Eval(5084, v is NestedClassGen<Decimal>[], false);
             Eval(5085, v is ImplementOneInterfaceC, false);
             Eval(5086, v is ImplementOneInterfaceC[], false);
             Eval(5087, v is ImplementTwoInterfaceC, false);
             Eval(5088, v is ImplementTwoInterfaceC[], false);
-            Eval(5089, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(5090, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(5091, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(5092, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(5093, v is ImplementAllInterfaceC<int>, false);
-            Eval(5094, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(5089, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(5090, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(5091, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(5092, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(5093, v is ImplementAllInterfaceC<int>, false);
+//            Eval(5094, v is ImplementAllInterfaceC<int>[], false);
             Eval(5095, v is SealedClass, false);
             Eval(5096, v is SealedClass[], false);
         }
@@ -5009,26 +5009,26 @@ internal class Program
             Eval(5102, v is NotEmptyStruct[], false);
             Eval(5103, v is NotEmptyStruct?, false);
             Eval(5104, v is NotEmptyStruct?[], false);
-            Eval(5105, v is EmptyStructGen<int>, false);
-            Eval(5106, v is EmptyStructGen<int>[], false);
-            Eval(5107, v is EmptyStructGen<int>?, false);
-            Eval(5108, v is EmptyStructGen<int>?[], false);
-            Eval(5109, v is NotEmptyStructGen<Guid>, false);
-            Eval(5110, v is NotEmptyStructGen<Guid>[], false);
-            Eval(5111, v is NotEmptyStructGen<Guid>?, false);
-            Eval(5112, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(5113, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(5114, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(5115, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(5116, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(5105, v is EmptyStructGen<int>, false);
+//            Eval(5106, v is EmptyStructGen<int>[], false);
+//            Eval(5107, v is EmptyStructGen<int>?, false);
+//            Eval(5108, v is EmptyStructGen<int>?[], false);
+//            Eval(5109, v is NotEmptyStructGen<Guid>, false);
+//            Eval(5110, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(5111, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(5112, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(5113, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(5114, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(5115, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(5116, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(5117, v is NestedStruct, true);
             Eval(5118, v is NestedStruct[], false);
             Eval(5119, v is NestedStruct?, true);
             Eval(5120, v is NestedStruct?[], false);
-            Eval(5121, v is NestedStructGen<Decimal>, false);
-            Eval(5122, v is NestedStructGen<Decimal>[], false);
-            Eval(5123, v is NestedStructGen<Decimal>?, false);
-            Eval(5124, v is NestedStructGen<Decimal>?[], false);
+//            Eval(5121, v is NestedStructGen<Decimal>, false);
+//            Eval(5122, v is NestedStructGen<Decimal>[], false);
+//            Eval(5123, v is NestedStructGen<Decimal>?, false);
+//            Eval(5124, v is NestedStructGen<Decimal>?[], false);
             Eval(5125, v is ExplicitFieldOffsetStruct, false);
             Eval(5126, v is ExplicitFieldOffsetStruct[], false);
             Eval(5127, v is ExplicitFieldOffsetStruct?, false);
@@ -5045,18 +5045,18 @@ internal class Program
             Eval(5146, v is ImplementTwoInterface[], false);
             Eval(5147, v is ImplementTwoInterface?, false);
             Eval(5148, v is ImplementTwoInterface?[], false);
-            Eval(5149, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(5150, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(5151, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(5152, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(5153, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(5154, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(5155, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(5156, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(5157, v is ImplementAllInterface<int>, false);
-            Eval(5158, v is ImplementAllInterface<int>[], false);
-            Eval(5159, v is ImplementAllInterface<int>?, false);
-            Eval(5160, v is ImplementAllInterface<int>?[], false);
+//            Eval(5149, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(5150, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(5151, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(5152, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(5153, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(5154, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(5155, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(5156, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(5157, v is ImplementAllInterface<int>, false);
+//            Eval(5158, v is ImplementAllInterface<int>[], false);
+//            Eval(5159, v is ImplementAllInterface<int>?, false);
+//            Eval(5160, v is ImplementAllInterface<int>?[], false);
             Eval(5161, v is IntE, false);
             Eval(5162, v is IntE[], false);
             Eval(5163, v is IntE?, false);
@@ -5155,38 +5155,38 @@ internal class Program
             Eval(5256, v is IEmpty[], false);
             Eval(5257, v is INotEmpty, false);
             Eval(5258, v is INotEmpty[], false);
-            Eval(5259, v is IEmptyGen<int>, false);
-            Eval(5260, v is IEmptyGen<int>[], false);
-            Eval(5261, v is INotEmptyGen<int>, false);
-            Eval(5262, v is INotEmptyGen<int>[], false);
+//            Eval(5259, v is IEmptyGen<int>, false);
+//            Eval(5260, v is IEmptyGen<int>[], false);
+//            Eval(5261, v is INotEmptyGen<int>, false);
+//            Eval(5262, v is INotEmptyGen<int>[], false);
             Eval(5263, v is SimpleDelegate, false);
             Eval(5264, v is SimpleDelegate[], false);
-            Eval(5265, v is GenericDelegate<int>, false);
-            Eval(5266, v is GenericDelegate<int>[], false);
+//            Eval(5265, v is GenericDelegate<int>, false);
+//            Eval(5266, v is GenericDelegate<int>[], false);
             Eval(5267, v is EmptyClass, false);
             Eval(5268, v is EmptyClass[], false);
             Eval(5269, v is NotEmptyClass, false);
             Eval(5270, v is NotEmptyClass[], false);
-            Eval(5271, v is EmptyClassGen<int>, false);
-            Eval(5272, v is EmptyClassGen<int>[], false);
-            Eval(5273, v is NotEmptyClassGen<Guid>, false);
-            Eval(5274, v is NotEmptyClassGen<Guid>[], false);
-            Eval(5275, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(5276, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(5271, v is EmptyClassGen<int>, false);
+//            Eval(5272, v is EmptyClassGen<int>[], false);
+//            Eval(5273, v is NotEmptyClassGen<Guid>, false);
+//            Eval(5274, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(5275, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(5276, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(5277, v is NestedClass, false);
             Eval(5278, v is NestedClass[], false);
-            Eval(5279, v is NestedClassGen<Decimal>, false);
-            Eval(5280, v is NestedClassGen<Decimal>[], false);
+//            Eval(5279, v is NestedClassGen<Decimal>, false);
+//            Eval(5280, v is NestedClassGen<Decimal>[], false);
             Eval(5281, v is ImplementOneInterfaceC, false);
             Eval(5282, v is ImplementOneInterfaceC[], false);
             Eval(5283, v is ImplementTwoInterfaceC, false);
             Eval(5284, v is ImplementTwoInterfaceC[], false);
-            Eval(5285, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(5286, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(5287, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(5288, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(5289, v is ImplementAllInterfaceC<int>, false);
-            Eval(5290, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(5285, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(5286, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(5287, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(5288, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(5289, v is ImplementAllInterfaceC<int>, false);
+//            Eval(5290, v is ImplementAllInterfaceC<int>[], false);
             Eval(5291, v is SealedClass, false);
             Eval(5292, v is SealedClass[], false);
         }
@@ -5200,26 +5200,26 @@ internal class Program
             Eval(5298, v is NotEmptyStruct[], false);
             Eval(5299, v is NotEmptyStruct?, false);
             Eval(5300, v is NotEmptyStruct?[], false);
-            Eval(5301, v is EmptyStructGen<int>, false);
-            Eval(5302, v is EmptyStructGen<int>[], false);
-            Eval(5303, v is EmptyStructGen<int>?, false);
-            Eval(5304, v is EmptyStructGen<int>?[], false);
-            Eval(5305, v is NotEmptyStructGen<Guid>, false);
-            Eval(5306, v is NotEmptyStructGen<Guid>[], false);
-            Eval(5307, v is NotEmptyStructGen<Guid>?, false);
-            Eval(5308, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(5309, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(5310, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(5311, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(5312, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(5301, v is EmptyStructGen<int>, false);
+//            Eval(5302, v is EmptyStructGen<int>[], false);
+//            Eval(5303, v is EmptyStructGen<int>?, false);
+//            Eval(5304, v is EmptyStructGen<int>?[], false);
+//            Eval(5305, v is NotEmptyStructGen<Guid>, false);
+//            Eval(5306, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(5307, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(5308, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(5309, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(5310, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(5311, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(5312, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(5313, v is NestedStruct, false);
             Eval(5314, v is NestedStruct[], false);
             Eval(5315, v is NestedStruct?, false);
             Eval(5316, v is NestedStruct?[], false);
-            Eval(5317, v is NestedStructGen<Decimal>, false);
-            Eval(5318, v is NestedStructGen<Decimal>[], false);
-            Eval(5319, v is NestedStructGen<Decimal>?, false);
-            Eval(5320, v is NestedStructGen<Decimal>?[], false);
+//            Eval(5317, v is NestedStructGen<Decimal>, false);
+//            Eval(5318, v is NestedStructGen<Decimal>[], false);
+//            Eval(5319, v is NestedStructGen<Decimal>?, false);
+//            Eval(5320, v is NestedStructGen<Decimal>?[], false);
             Eval(5321, v is ExplicitFieldOffsetStruct, false);
             Eval(5322, v is ExplicitFieldOffsetStruct[], false);
             Eval(5323, v is ExplicitFieldOffsetStruct?, false);
@@ -5236,18 +5236,18 @@ internal class Program
             Eval(5342, v is ImplementTwoInterface[], false);
             Eval(5343, v is ImplementTwoInterface?, false);
             Eval(5344, v is ImplementTwoInterface?[], false);
-            Eval(5345, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(5346, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(5347, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(5348, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(5349, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(5350, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(5351, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(5352, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(5353, v is ImplementAllInterface<int>, false);
-            Eval(5354, v is ImplementAllInterface<int>[], false);
-            Eval(5355, v is ImplementAllInterface<int>?, false);
-            Eval(5356, v is ImplementAllInterface<int>?[], false);
+//            Eval(5345, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(5346, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(5347, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(5348, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(5349, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(5350, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(5351, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(5352, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(5353, v is ImplementAllInterface<int>, false);
+//            Eval(5354, v is ImplementAllInterface<int>[], false);
+//            Eval(5355, v is ImplementAllInterface<int>?, false);
+//            Eval(5356, v is ImplementAllInterface<int>?[], false);
             Eval(5357, v is IntE, false);
             Eval(5358, v is IntE[], false);
             Eval(5359, v is IntE?, false);
@@ -5346,38 +5346,38 @@ internal class Program
             Eval(5452, v is IEmpty[], false);
             Eval(5453, v is INotEmpty, false);
             Eval(5454, v is INotEmpty[], false);
-            Eval(5455, v is IEmptyGen<int>, false);
-            Eval(5456, v is IEmptyGen<int>[], false);
-            Eval(5457, v is INotEmptyGen<int>, false);
-            Eval(5458, v is INotEmptyGen<int>[], false);
+//            Eval(5455, v is IEmptyGen<int>, false);
+//            Eval(5456, v is IEmptyGen<int>[], false);
+//            Eval(5457, v is INotEmptyGen<int>, false);
+//            Eval(5458, v is INotEmptyGen<int>[], false);
             Eval(5459, v is SimpleDelegate, false);
             Eval(5460, v is SimpleDelegate[], false);
-            Eval(5461, v is GenericDelegate<int>, false);
-            Eval(5462, v is GenericDelegate<int>[], false);
+//            Eval(5461, v is GenericDelegate<int>, false);
+//            Eval(5462, v is GenericDelegate<int>[], false);
             Eval(5463, v is EmptyClass, false);
             Eval(5464, v is EmptyClass[], false);
             Eval(5465, v is NotEmptyClass, false);
             Eval(5466, v is NotEmptyClass[], false);
-            Eval(5467, v is EmptyClassGen<int>, false);
-            Eval(5468, v is EmptyClassGen<int>[], false);
-            Eval(5469, v is NotEmptyClassGen<Guid>, false);
-            Eval(5470, v is NotEmptyClassGen<Guid>[], false);
-            Eval(5471, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(5472, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(5467, v is EmptyClassGen<int>, false);
+//            Eval(5468, v is EmptyClassGen<int>[], false);
+//            Eval(5469, v is NotEmptyClassGen<Guid>, false);
+//            Eval(5470, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(5471, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(5472, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(5473, v is NestedClass, false);
             Eval(5474, v is NestedClass[], false);
-            Eval(5475, v is NestedClassGen<Decimal>, false);
-            Eval(5476, v is NestedClassGen<Decimal>[], false);
+//            Eval(5475, v is NestedClassGen<Decimal>, false);
+//            Eval(5476, v is NestedClassGen<Decimal>[], false);
             Eval(5477, v is ImplementOneInterfaceC, false);
             Eval(5478, v is ImplementOneInterfaceC[], false);
             Eval(5479, v is ImplementTwoInterfaceC, false);
             Eval(5480, v is ImplementTwoInterfaceC[], false);
-            Eval(5481, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(5482, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(5483, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(5484, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(5485, v is ImplementAllInterfaceC<int>, false);
-            Eval(5486, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(5481, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(5482, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(5483, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(5484, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(5485, v is ImplementAllInterfaceC<int>, false);
+//            Eval(5486, v is ImplementAllInterfaceC<int>[], false);
             Eval(5487, v is SealedClass, false);
             Eval(5488, v is SealedClass[], false);
         }
@@ -5391,26 +5391,26 @@ internal class Program
             Eval(5494, v is NotEmptyStruct[], false);
             Eval(5495, v is NotEmptyStruct?, false);
             Eval(5496, v is NotEmptyStruct?[], false);
-            Eval(5497, v is EmptyStructGen<int>, false);
-            Eval(5498, v is EmptyStructGen<int>[], false);
-            Eval(5499, v is EmptyStructGen<int>?, false);
-            Eval(5500, v is EmptyStructGen<int>?[], false);
-            Eval(5501, v is NotEmptyStructGen<Guid>, false);
-            Eval(5502, v is NotEmptyStructGen<Guid>[], false);
-            Eval(5503, v is NotEmptyStructGen<Guid>?, false);
-            Eval(5504, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(5505, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(5506, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(5507, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(5508, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(5497, v is EmptyStructGen<int>, false);
+//            Eval(5498, v is EmptyStructGen<int>[], false);
+//            Eval(5499, v is EmptyStructGen<int>?, false);
+//            Eval(5500, v is EmptyStructGen<int>?[], false);
+//            Eval(5501, v is NotEmptyStructGen<Guid>, false);
+//            Eval(5502, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(5503, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(5504, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(5505, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(5506, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(5507, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(5508, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(5509, v is NestedStruct, false);
             Eval(5510, v is NestedStruct[], false);
             Eval(5511, v is NestedStruct?, false);
             Eval(5512, v is NestedStruct?[], false);
-            Eval(5513, v is NestedStructGen<Decimal>, false);
-            Eval(5514, v is NestedStructGen<Decimal>[], false);
-            Eval(5515, v is NestedStructGen<Decimal>?, false);
-            Eval(5516, v is NestedStructGen<Decimal>?[], false);
+//            Eval(5513, v is NestedStructGen<Decimal>, false);
+//            Eval(5514, v is NestedStructGen<Decimal>[], false);
+//            Eval(5515, v is NestedStructGen<Decimal>?, false);
+//            Eval(5516, v is NestedStructGen<Decimal>?[], false);
             Eval(5517, v is ExplicitFieldOffsetStruct, false);
             Eval(5518, v is ExplicitFieldOffsetStruct[], false);
             Eval(5519, v is ExplicitFieldOffsetStruct?, false);
@@ -5427,18 +5427,18 @@ internal class Program
             Eval(5538, v is ImplementTwoInterface[], false);
             Eval(5539, v is ImplementTwoInterface?, false);
             Eval(5540, v is ImplementTwoInterface?[], false);
-            Eval(5541, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(5542, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(5543, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(5544, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(5545, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(5546, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(5547, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(5548, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(5549, v is ImplementAllInterface<int>, false);
-            Eval(5550, v is ImplementAllInterface<int>[], false);
-            Eval(5551, v is ImplementAllInterface<int>?, false);
-            Eval(5552, v is ImplementAllInterface<int>?[], false);
+//            Eval(5541, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(5542, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(5543, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(5544, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(5545, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(5546, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(5547, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(5548, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(5549, v is ImplementAllInterface<int>, false);
+//            Eval(5550, v is ImplementAllInterface<int>[], false);
+//            Eval(5551, v is ImplementAllInterface<int>?, false);
+//            Eval(5552, v is ImplementAllInterface<int>?[], false);
             Eval(5553, v is IntE, false);
             Eval(5554, v is IntE[], false);
             Eval(5555, v is IntE?, false);
@@ -5537,38 +5537,38 @@ internal class Program
             Eval(5648, v is IEmpty[], false);
             Eval(5649, v is INotEmpty, false);
             Eval(5650, v is INotEmpty[], false);
-            Eval(5651, v is IEmptyGen<int>, false);
-            Eval(5652, v is IEmptyGen<int>[], false);
-            Eval(5653, v is INotEmptyGen<int>, false);
-            Eval(5654, v is INotEmptyGen<int>[], false);
+//            Eval(5651, v is IEmptyGen<int>, false);
+//            Eval(5652, v is IEmptyGen<int>[], false);
+//            Eval(5653, v is INotEmptyGen<int>, false);
+//            Eval(5654, v is INotEmptyGen<int>[], false);
             Eval(5655, v is SimpleDelegate, false);
             Eval(5656, v is SimpleDelegate[], false);
-            Eval(5657, v is GenericDelegate<int>, false);
-            Eval(5658, v is GenericDelegate<int>[], false);
+//            Eval(5657, v is GenericDelegate<int>, false);
+//            Eval(5658, v is GenericDelegate<int>[], false);
             Eval(5659, v is EmptyClass, false);
             Eval(5660, v is EmptyClass[], false);
             Eval(5661, v is NotEmptyClass, false);
             Eval(5662, v is NotEmptyClass[], false);
-            Eval(5663, v is EmptyClassGen<int>, false);
-            Eval(5664, v is EmptyClassGen<int>[], false);
-            Eval(5665, v is NotEmptyClassGen<Guid>, false);
-            Eval(5666, v is NotEmptyClassGen<Guid>[], false);
-            Eval(5667, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(5668, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(5663, v is EmptyClassGen<int>, false);
+//            Eval(5664, v is EmptyClassGen<int>[], false);
+//            Eval(5665, v is NotEmptyClassGen<Guid>, false);
+//            Eval(5666, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(5667, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(5668, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(5669, v is NestedClass, false);
             Eval(5670, v is NestedClass[], false);
-            Eval(5671, v is NestedClassGen<Decimal>, false);
-            Eval(5672, v is NestedClassGen<Decimal>[], false);
+//            Eval(5671, v is NestedClassGen<Decimal>, false);
+//            Eval(5672, v is NestedClassGen<Decimal>[], false);
             Eval(5673, v is ImplementOneInterfaceC, false);
             Eval(5674, v is ImplementOneInterfaceC[], false);
             Eval(5675, v is ImplementTwoInterfaceC, false);
             Eval(5676, v is ImplementTwoInterfaceC[], false);
-            Eval(5677, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(5678, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(5679, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(5680, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(5681, v is ImplementAllInterfaceC<int>, false);
-            Eval(5682, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(5677, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(5678, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(5679, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(5680, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(5681, v is ImplementAllInterfaceC<int>, false);
+//            Eval(5682, v is ImplementAllInterfaceC<int>[], false);
             Eval(5683, v is SealedClass, false);
             Eval(5684, v is SealedClass[], false);
         }
@@ -5582,26 +5582,26 @@ internal class Program
             Eval(5690, v is NotEmptyStruct[], false);
             Eval(5691, v is NotEmptyStruct?, false);
             Eval(5692, v is NotEmptyStruct?[], false);
-            Eval(5693, v is EmptyStructGen<int>, false);
-            Eval(5694, v is EmptyStructGen<int>[], false);
-            Eval(5695, v is EmptyStructGen<int>?, false);
-            Eval(5696, v is EmptyStructGen<int>?[], false);
-            Eval(5697, v is NotEmptyStructGen<Guid>, false);
-            Eval(5698, v is NotEmptyStructGen<Guid>[], false);
-            Eval(5699, v is NotEmptyStructGen<Guid>?, false);
-            Eval(5700, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(5701, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(5702, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(5703, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(5704, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(5693, v is EmptyStructGen<int>, false);
+//            Eval(5694, v is EmptyStructGen<int>[], false);
+//            Eval(5695, v is EmptyStructGen<int>?, false);
+//            Eval(5696, v is EmptyStructGen<int>?[], false);
+//            Eval(5697, v is NotEmptyStructGen<Guid>, false);
+//            Eval(5698, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(5699, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(5700, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(5701, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(5702, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(5703, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(5704, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(5705, v is NestedStruct, false);
             Eval(5706, v is NestedStruct[], false);
             Eval(5707, v is NestedStruct?, false);
             Eval(5708, v is NestedStruct?[], true);
-            Eval(5709, v is NestedStructGen<Decimal>, false);
-            Eval(5710, v is NestedStructGen<Decimal>[], false);
-            Eval(5711, v is NestedStructGen<Decimal>?, false);
-            Eval(5712, v is NestedStructGen<Decimal>?[], false);
+//            Eval(5709, v is NestedStructGen<Decimal>, false);
+//            Eval(5710, v is NestedStructGen<Decimal>[], false);
+//            Eval(5711, v is NestedStructGen<Decimal>?, false);
+//            Eval(5712, v is NestedStructGen<Decimal>?[], false);
             Eval(5713, v is ExplicitFieldOffsetStruct, false);
             Eval(5714, v is ExplicitFieldOffsetStruct[], false);
             Eval(5715, v is ExplicitFieldOffsetStruct?, false);
@@ -5618,18 +5618,18 @@ internal class Program
             Eval(5734, v is ImplementTwoInterface[], false);
             Eval(5735, v is ImplementTwoInterface?, false);
             Eval(5736, v is ImplementTwoInterface?[], false);
-            Eval(5737, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(5738, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(5739, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(5740, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(5741, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(5742, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(5743, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(5744, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(5745, v is ImplementAllInterface<int>, false);
-            Eval(5746, v is ImplementAllInterface<int>[], false);
-            Eval(5747, v is ImplementAllInterface<int>?, false);
-            Eval(5748, v is ImplementAllInterface<int>?[], false);
+//            Eval(5737, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(5738, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(5739, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(5740, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(5741, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(5742, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(5743, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(5744, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(5745, v is ImplementAllInterface<int>, false);
+//            Eval(5746, v is ImplementAllInterface<int>[], false);
+//            Eval(5747, v is ImplementAllInterface<int>?, false);
+//            Eval(5748, v is ImplementAllInterface<int>?[], false);
             Eval(5749, v is IntE, false);
             Eval(5750, v is IntE[], false);
             Eval(5751, v is IntE?, false);
@@ -5728,38 +5728,38 @@ internal class Program
             Eval(5844, v is IEmpty[], false);
             Eval(5845, v is INotEmpty, false);
             Eval(5846, v is INotEmpty[], false);
-            Eval(5847, v is IEmptyGen<int>, false);
-            Eval(5848, v is IEmptyGen<int>[], false);
-            Eval(5849, v is INotEmptyGen<int>, false);
-            Eval(5850, v is INotEmptyGen<int>[], false);
+//            Eval(5847, v is IEmptyGen<int>, false);
+//            Eval(5848, v is IEmptyGen<int>[], false);
+//            Eval(5849, v is INotEmptyGen<int>, false);
+//            Eval(5850, v is INotEmptyGen<int>[], false);
             Eval(5851, v is SimpleDelegate, false);
             Eval(5852, v is SimpleDelegate[], false);
-            Eval(5853, v is GenericDelegate<int>, false);
-            Eval(5854, v is GenericDelegate<int>[], false);
+//            Eval(5853, v is GenericDelegate<int>, false);
+//            Eval(5854, v is GenericDelegate<int>[], false);
             Eval(5855, v is EmptyClass, false);
             Eval(5856, v is EmptyClass[], false);
             Eval(5857, v is NotEmptyClass, false);
             Eval(5858, v is NotEmptyClass[], false);
-            Eval(5859, v is EmptyClassGen<int>, false);
-            Eval(5860, v is EmptyClassGen<int>[], false);
-            Eval(5861, v is NotEmptyClassGen<Guid>, false);
-            Eval(5862, v is NotEmptyClassGen<Guid>[], false);
-            Eval(5863, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(5864, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(5859, v is EmptyClassGen<int>, false);
+//            Eval(5860, v is EmptyClassGen<int>[], false);
+//            Eval(5861, v is NotEmptyClassGen<Guid>, false);
+//            Eval(5862, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(5863, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(5864, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(5865, v is NestedClass, false);
             Eval(5866, v is NestedClass[], false);
-            Eval(5867, v is NestedClassGen<Decimal>, false);
-            Eval(5868, v is NestedClassGen<Decimal>[], false);
+//            Eval(5867, v is NestedClassGen<Decimal>, false);
+//            Eval(5868, v is NestedClassGen<Decimal>[], false);
             Eval(5869, v is ImplementOneInterfaceC, false);
             Eval(5870, v is ImplementOneInterfaceC[], false);
             Eval(5871, v is ImplementTwoInterfaceC, false);
             Eval(5872, v is ImplementTwoInterfaceC[], false);
-            Eval(5873, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(5874, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(5875, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(5876, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(5877, v is ImplementAllInterfaceC<int>, false);
-            Eval(5878, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(5873, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(5874, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(5875, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(5876, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(5877, v is ImplementAllInterfaceC<int>, false);
+//            Eval(5878, v is ImplementAllInterfaceC<int>[], false);
             Eval(5879, v is SealedClass, false);
             Eval(5880, v is SealedClass[], false);
         }
@@ -5776,26 +5776,26 @@ internal class Program
             Eval(5886, v is NotEmptyStruct[], false);
             Eval(5887, v is NotEmptyStruct?, false);
             Eval(5888, v is NotEmptyStruct?[], false);
-            Eval(5889, v is EmptyStructGen<int>, false);
-            Eval(5890, v is EmptyStructGen<int>[], false);
-            Eval(5891, v is EmptyStructGen<int>?, false);
-            Eval(5892, v is EmptyStructGen<int>?[], false);
-            Eval(5893, v is NotEmptyStructGen<Guid>, false);
-            Eval(5894, v is NotEmptyStructGen<Guid>[], false);
-            Eval(5895, v is NotEmptyStructGen<Guid>?, false);
-            Eval(5896, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(5897, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(5898, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(5899, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(5900, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(5889, v is EmptyStructGen<int>, false);
+//            Eval(5890, v is EmptyStructGen<int>[], false);
+//            Eval(5891, v is EmptyStructGen<int>?, false);
+//            Eval(5892, v is EmptyStructGen<int>?[], false);
+//            Eval(5893, v is NotEmptyStructGen<Guid>, false);
+//            Eval(5894, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(5895, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(5896, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(5897, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(5898, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(5899, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(5900, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(5901, v is NestedStruct, false);
             Eval(5902, v is NestedStruct[], false);
             Eval(5903, v is NestedStruct?, false);
             Eval(5904, v is NestedStruct?[], false);
-            Eval(5905, v is NestedStructGen<Decimal>, true);
-            Eval(5906, v is NestedStructGen<Decimal>[], false);
-            Eval(5907, v is NestedStructGen<Decimal>?, true);
-            Eval(5908, v is NestedStructGen<Decimal>?[], false);
+//            Eval(5905, v is NestedStructGen<Decimal>, true);
+//            Eval(5906, v is NestedStructGen<Decimal>[], false);
+//            Eval(5907, v is NestedStructGen<Decimal>?, true);
+//            Eval(5908, v is NestedStructGen<Decimal>?[], false);
             Eval(5909, v is ExplicitFieldOffsetStruct, false);
             Eval(5910, v is ExplicitFieldOffsetStruct[], false);
             Eval(5911, v is ExplicitFieldOffsetStruct?, false);
@@ -5812,18 +5812,18 @@ internal class Program
             Eval(5930, v is ImplementTwoInterface[], false);
             Eval(5931, v is ImplementTwoInterface?, false);
             Eval(5932, v is ImplementTwoInterface?[], false);
-            Eval(5933, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(5934, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(5935, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(5936, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(5937, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(5938, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(5939, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(5940, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(5941, v is ImplementAllInterface<int>, false);
-            Eval(5942, v is ImplementAllInterface<int>[], false);
-            Eval(5943, v is ImplementAllInterface<int>?, false);
-            Eval(5944, v is ImplementAllInterface<int>?[], false);
+//            Eval(5933, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(5934, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(5935, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(5936, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(5937, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(5938, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(5939, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(5940, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(5941, v is ImplementAllInterface<int>, false);
+//            Eval(5942, v is ImplementAllInterface<int>[], false);
+//            Eval(5943, v is ImplementAllInterface<int>?, false);
+//            Eval(5944, v is ImplementAllInterface<int>?[], false);
             Eval(5945, v is IntE, false);
             Eval(5946, v is IntE[], false);
             Eval(5947, v is IntE?, false);
@@ -5922,38 +5922,38 @@ internal class Program
             Eval(6040, v is IEmpty[], false);
             Eval(6041, v is INotEmpty, false);
             Eval(6042, v is INotEmpty[], false);
-            Eval(6043, v is IEmptyGen<int>, false);
-            Eval(6044, v is IEmptyGen<int>[], false);
-            Eval(6045, v is INotEmptyGen<int>, false);
-            Eval(6046, v is INotEmptyGen<int>[], false);
+//            Eval(6043, v is IEmptyGen<int>, false);
+//            Eval(6044, v is IEmptyGen<int>[], false);
+//            Eval(6045, v is INotEmptyGen<int>, false);
+//            Eval(6046, v is INotEmptyGen<int>[], false);
             Eval(6047, v is SimpleDelegate, false);
             Eval(6048, v is SimpleDelegate[], false);
-            Eval(6049, v is GenericDelegate<int>, false);
-            Eval(6050, v is GenericDelegate<int>[], false);
+//            Eval(6049, v is GenericDelegate<int>, false);
+//            Eval(6050, v is GenericDelegate<int>[], false);
             Eval(6051, v is EmptyClass, false);
             Eval(6052, v is EmptyClass[], false);
             Eval(6053, v is NotEmptyClass, false);
             Eval(6054, v is NotEmptyClass[], false);
-            Eval(6055, v is EmptyClassGen<int>, false);
-            Eval(6056, v is EmptyClassGen<int>[], false);
-            Eval(6057, v is NotEmptyClassGen<Guid>, false);
-            Eval(6058, v is NotEmptyClassGen<Guid>[], false);
-            Eval(6059, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(6060, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(6055, v is EmptyClassGen<int>, false);
+//            Eval(6056, v is EmptyClassGen<int>[], false);
+//            Eval(6057, v is NotEmptyClassGen<Guid>, false);
+//            Eval(6058, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(6059, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(6060, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(6061, v is NestedClass, false);
             Eval(6062, v is NestedClass[], false);
-            Eval(6063, v is NestedClassGen<Decimal>, false);
-            Eval(6064, v is NestedClassGen<Decimal>[], false);
+//            Eval(6063, v is NestedClassGen<Decimal>, false);
+//            Eval(6064, v is NestedClassGen<Decimal>[], false);
             Eval(6065, v is ImplementOneInterfaceC, false);
             Eval(6066, v is ImplementOneInterfaceC[], false);
             Eval(6067, v is ImplementTwoInterfaceC, false);
             Eval(6068, v is ImplementTwoInterfaceC[], false);
-            Eval(6069, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(6070, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(6071, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(6072, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(6073, v is ImplementAllInterfaceC<int>, false);
-            Eval(6074, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(6069, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(6070, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(6071, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(6072, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(6073, v is ImplementAllInterfaceC<int>, false);
+//            Eval(6074, v is ImplementAllInterfaceC<int>[], false);
             Eval(6075, v is SealedClass, false);
             Eval(6076, v is SealedClass[], false);
         }
@@ -5967,26 +5967,26 @@ internal class Program
             Eval(6082, v is NotEmptyStruct[], false);
             Eval(6083, v is NotEmptyStruct?, false);
             Eval(6084, v is NotEmptyStruct?[], false);
-            Eval(6085, v is EmptyStructGen<int>, false);
-            Eval(6086, v is EmptyStructGen<int>[], false);
-            Eval(6087, v is EmptyStructGen<int>?, false);
-            Eval(6088, v is EmptyStructGen<int>?[], false);
-            Eval(6089, v is NotEmptyStructGen<Guid>, false);
-            Eval(6090, v is NotEmptyStructGen<Guid>[], false);
-            Eval(6091, v is NotEmptyStructGen<Guid>?, false);
-            Eval(6092, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(6093, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(6094, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(6095, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(6096, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(6085, v is EmptyStructGen<int>, false);
+//            Eval(6086, v is EmptyStructGen<int>[], false);
+//            Eval(6087, v is EmptyStructGen<int>?, false);
+//            Eval(6088, v is EmptyStructGen<int>?[], false);
+//            Eval(6089, v is NotEmptyStructGen<Guid>, false);
+//            Eval(6090, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(6091, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(6092, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(6093, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(6094, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(6095, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(6096, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(6097, v is NestedStruct, false);
             Eval(6098, v is NestedStruct[], false);
             Eval(6099, v is NestedStruct?, false);
             Eval(6100, v is NestedStruct?[], false);
-            Eval(6101, v is NestedStructGen<Decimal>, true);
-            Eval(6102, v is NestedStructGen<Decimal>[], false);
-            Eval(6103, v is NestedStructGen<Decimal>?, true);
-            Eval(6104, v is NestedStructGen<Decimal>?[], false);
+//            Eval(6101, v is NestedStructGen<Decimal>, true);
+//            Eval(6102, v is NestedStructGen<Decimal>[], false);
+//            Eval(6103, v is NestedStructGen<Decimal>?, true);
+//            Eval(6104, v is NestedStructGen<Decimal>?[], false);
             Eval(6105, v is ExplicitFieldOffsetStruct, false);
             Eval(6106, v is ExplicitFieldOffsetStruct[], false);
             Eval(6107, v is ExplicitFieldOffsetStruct?, false);
@@ -6003,18 +6003,18 @@ internal class Program
             Eval(6126, v is ImplementTwoInterface[], false);
             Eval(6127, v is ImplementTwoInterface?, false);
             Eval(6128, v is ImplementTwoInterface?[], false);
-            Eval(6129, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(6130, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(6131, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(6132, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(6133, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(6134, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(6135, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(6136, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(6137, v is ImplementAllInterface<int>, false);
-            Eval(6138, v is ImplementAllInterface<int>[], false);
-            Eval(6139, v is ImplementAllInterface<int>?, false);
-            Eval(6140, v is ImplementAllInterface<int>?[], false);
+//            Eval(6129, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(6130, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(6131, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(6132, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(6133, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(6134, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(6135, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(6136, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(6137, v is ImplementAllInterface<int>, false);
+//            Eval(6138, v is ImplementAllInterface<int>[], false);
+//            Eval(6139, v is ImplementAllInterface<int>?, false);
+//            Eval(6140, v is ImplementAllInterface<int>?[], false);
             Eval(6141, v is IntE, false);
             Eval(6142, v is IntE[], false);
             Eval(6143, v is IntE?, false);
@@ -6113,38 +6113,38 @@ internal class Program
             Eval(6236, v is IEmpty[], false);
             Eval(6237, v is INotEmpty, false);
             Eval(6238, v is INotEmpty[], false);
-            Eval(6239, v is IEmptyGen<int>, false);
-            Eval(6240, v is IEmptyGen<int>[], false);
-            Eval(6241, v is INotEmptyGen<int>, false);
-            Eval(6242, v is INotEmptyGen<int>[], false);
+//            Eval(6239, v is IEmptyGen<int>, false);
+//            Eval(6240, v is IEmptyGen<int>[], false);
+//            Eval(6241, v is INotEmptyGen<int>, false);
+//            Eval(6242, v is INotEmptyGen<int>[], false);
             Eval(6243, v is SimpleDelegate, false);
             Eval(6244, v is SimpleDelegate[], false);
-            Eval(6245, v is GenericDelegate<int>, false);
-            Eval(6246, v is GenericDelegate<int>[], false);
+//            Eval(6245, v is GenericDelegate<int>, false);
+//            Eval(6246, v is GenericDelegate<int>[], false);
             Eval(6247, v is EmptyClass, false);
             Eval(6248, v is EmptyClass[], false);
             Eval(6249, v is NotEmptyClass, false);
             Eval(6250, v is NotEmptyClass[], false);
-            Eval(6251, v is EmptyClassGen<int>, false);
-            Eval(6252, v is EmptyClassGen<int>[], false);
-            Eval(6253, v is NotEmptyClassGen<Guid>, false);
-            Eval(6254, v is NotEmptyClassGen<Guid>[], false);
-            Eval(6255, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(6256, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(6251, v is EmptyClassGen<int>, false);
+//            Eval(6252, v is EmptyClassGen<int>[], false);
+//            Eval(6253, v is NotEmptyClassGen<Guid>, false);
+//            Eval(6254, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(6255, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(6256, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(6257, v is NestedClass, false);
             Eval(6258, v is NestedClass[], false);
-            Eval(6259, v is NestedClassGen<Decimal>, false);
-            Eval(6260, v is NestedClassGen<Decimal>[], false);
+//            Eval(6259, v is NestedClassGen<Decimal>, false);
+//            Eval(6260, v is NestedClassGen<Decimal>[], false);
             Eval(6261, v is ImplementOneInterfaceC, false);
             Eval(6262, v is ImplementOneInterfaceC[], false);
             Eval(6263, v is ImplementTwoInterfaceC, false);
             Eval(6264, v is ImplementTwoInterfaceC[], false);
-            Eval(6265, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(6266, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(6267, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(6268, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(6269, v is ImplementAllInterfaceC<int>, false);
-            Eval(6270, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(6265, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(6266, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(6267, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(6268, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(6269, v is ImplementAllInterfaceC<int>, false);
+//            Eval(6270, v is ImplementAllInterfaceC<int>[], false);
             Eval(6271, v is SealedClass, false);
             Eval(6272, v is SealedClass[], false);
         }
@@ -6158,26 +6158,26 @@ internal class Program
             Eval(6278, v is NotEmptyStruct[], false);
             Eval(6279, v is NotEmptyStruct?, false);
             Eval(6280, v is NotEmptyStruct?[], false);
-            Eval(6281, v is EmptyStructGen<int>, false);
-            Eval(6282, v is EmptyStructGen<int>[], false);
-            Eval(6283, v is EmptyStructGen<int>?, false);
-            Eval(6284, v is EmptyStructGen<int>?[], false);
-            Eval(6285, v is NotEmptyStructGen<Guid>, false);
-            Eval(6286, v is NotEmptyStructGen<Guid>[], false);
-            Eval(6287, v is NotEmptyStructGen<Guid>?, false);
-            Eval(6288, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(6289, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(6290, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(6291, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(6292, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(6281, v is EmptyStructGen<int>, false);
+//            Eval(6282, v is EmptyStructGen<int>[], false);
+//            Eval(6283, v is EmptyStructGen<int>?, false);
+//            Eval(6284, v is EmptyStructGen<int>?[], false);
+//            Eval(6285, v is NotEmptyStructGen<Guid>, false);
+//            Eval(6286, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(6287, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(6288, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(6289, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(6290, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(6291, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(6292, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(6293, v is NestedStruct, false);
             Eval(6294, v is NestedStruct[], false);
             Eval(6295, v is NestedStruct?, false);
             Eval(6296, v is NestedStruct?[], false);
-            Eval(6297, v is NestedStructGen<Decimal>, false);
-            Eval(6298, v is NestedStructGen<Decimal>[], false);
-            Eval(6299, v is NestedStructGen<Decimal>?, false);
-            Eval(6300, v is NestedStructGen<Decimal>?[], false);
+//            Eval(6297, v is NestedStructGen<Decimal>, false);
+//            Eval(6298, v is NestedStructGen<Decimal>[], false);
+//            Eval(6299, v is NestedStructGen<Decimal>?, false);
+//            Eval(6300, v is NestedStructGen<Decimal>?[], false);
             Eval(6301, v is ExplicitFieldOffsetStruct, false);
             Eval(6302, v is ExplicitFieldOffsetStruct[], false);
             Eval(6303, v is ExplicitFieldOffsetStruct?, false);
@@ -6194,18 +6194,18 @@ internal class Program
             Eval(6322, v is ImplementTwoInterface[], false);
             Eval(6323, v is ImplementTwoInterface?, false);
             Eval(6324, v is ImplementTwoInterface?[], false);
-            Eval(6325, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(6326, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(6327, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(6328, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(6329, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(6330, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(6331, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(6332, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(6333, v is ImplementAllInterface<int>, false);
-            Eval(6334, v is ImplementAllInterface<int>[], false);
-            Eval(6335, v is ImplementAllInterface<int>?, false);
-            Eval(6336, v is ImplementAllInterface<int>?[], false);
+//            Eval(6325, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(6326, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(6327, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(6328, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(6329, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(6330, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(6331, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(6332, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(6333, v is ImplementAllInterface<int>, false);
+//            Eval(6334, v is ImplementAllInterface<int>[], false);
+//            Eval(6335, v is ImplementAllInterface<int>?, false);
+//            Eval(6336, v is ImplementAllInterface<int>?[], false);
             Eval(6337, v is IntE, false);
             Eval(6338, v is IntE[], false);
             Eval(6339, v is IntE?, false);
@@ -6304,38 +6304,38 @@ internal class Program
             Eval(6432, v is IEmpty[], false);
             Eval(6433, v is INotEmpty, false);
             Eval(6434, v is INotEmpty[], false);
-            Eval(6435, v is IEmptyGen<int>, false);
-            Eval(6436, v is IEmptyGen<int>[], false);
-            Eval(6437, v is INotEmptyGen<int>, false);
-            Eval(6438, v is INotEmptyGen<int>[], false);
+//            Eval(6435, v is IEmptyGen<int>, false);
+//            Eval(6436, v is IEmptyGen<int>[], false);
+//            Eval(6437, v is INotEmptyGen<int>, false);
+//            Eval(6438, v is INotEmptyGen<int>[], false);
             Eval(6439, v is SimpleDelegate, false);
             Eval(6440, v is SimpleDelegate[], false);
-            Eval(6441, v is GenericDelegate<int>, false);
-            Eval(6442, v is GenericDelegate<int>[], false);
+//            Eval(6441, v is GenericDelegate<int>, false);
+//            Eval(6442, v is GenericDelegate<int>[], false);
             Eval(6443, v is EmptyClass, false);
             Eval(6444, v is EmptyClass[], false);
             Eval(6445, v is NotEmptyClass, false);
             Eval(6446, v is NotEmptyClass[], false);
-            Eval(6447, v is EmptyClassGen<int>, false);
-            Eval(6448, v is EmptyClassGen<int>[], false);
-            Eval(6449, v is NotEmptyClassGen<Guid>, false);
-            Eval(6450, v is NotEmptyClassGen<Guid>[], false);
-            Eval(6451, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(6452, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(6447, v is EmptyClassGen<int>, false);
+//            Eval(6448, v is EmptyClassGen<int>[], false);
+//            Eval(6449, v is NotEmptyClassGen<Guid>, false);
+//            Eval(6450, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(6451, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(6452, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(6453, v is NestedClass, false);
             Eval(6454, v is NestedClass[], false);
-            Eval(6455, v is NestedClassGen<Decimal>, false);
-            Eval(6456, v is NestedClassGen<Decimal>[], false);
+//            Eval(6455, v is NestedClassGen<Decimal>, false);
+//            Eval(6456, v is NestedClassGen<Decimal>[], false);
             Eval(6457, v is ImplementOneInterfaceC, false);
             Eval(6458, v is ImplementOneInterfaceC[], false);
             Eval(6459, v is ImplementTwoInterfaceC, false);
             Eval(6460, v is ImplementTwoInterfaceC[], false);
-            Eval(6461, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(6462, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(6463, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(6464, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(6465, v is ImplementAllInterfaceC<int>, false);
-            Eval(6466, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(6461, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(6462, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(6463, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(6464, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(6465, v is ImplementAllInterfaceC<int>, false);
+//            Eval(6466, v is ImplementAllInterfaceC<int>[], false);
             Eval(6467, v is SealedClass, false);
             Eval(6468, v is SealedClass[], false);
         }
@@ -6349,26 +6349,26 @@ internal class Program
             Eval(6474, v is NotEmptyStruct[], false);
             Eval(6475, v is NotEmptyStruct?, false);
             Eval(6476, v is NotEmptyStruct?[], false);
-            Eval(6477, v is EmptyStructGen<int>, false);
-            Eval(6478, v is EmptyStructGen<int>[], false);
-            Eval(6479, v is EmptyStructGen<int>?, false);
-            Eval(6480, v is EmptyStructGen<int>?[], false);
-            Eval(6481, v is NotEmptyStructGen<Guid>, false);
-            Eval(6482, v is NotEmptyStructGen<Guid>[], false);
-            Eval(6483, v is NotEmptyStructGen<Guid>?, false);
-            Eval(6484, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(6485, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(6486, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(6487, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(6488, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(6477, v is EmptyStructGen<int>, false);
+//            Eval(6478, v is EmptyStructGen<int>[], false);
+//            Eval(6479, v is EmptyStructGen<int>?, false);
+//            Eval(6480, v is EmptyStructGen<int>?[], false);
+//            Eval(6481, v is NotEmptyStructGen<Guid>, false);
+//            Eval(6482, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(6483, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(6484, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(6485, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(6486, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(6487, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(6488, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(6489, v is NestedStruct, false);
             Eval(6490, v is NestedStruct[], false);
             Eval(6491, v is NestedStruct?, false);
             Eval(6492, v is NestedStruct?[], false);
-            Eval(6493, v is NestedStructGen<Decimal>, false);
-            Eval(6494, v is NestedStructGen<Decimal>[], false);
-            Eval(6495, v is NestedStructGen<Decimal>?, false);
-            Eval(6496, v is NestedStructGen<Decimal>?[], false);
+//            Eval(6493, v is NestedStructGen<Decimal>, false);
+//            Eval(6494, v is NestedStructGen<Decimal>[], false);
+//            Eval(6495, v is NestedStructGen<Decimal>?, false);
+//            Eval(6496, v is NestedStructGen<Decimal>?[], false);
             Eval(6497, v is ExplicitFieldOffsetStruct, false);
             Eval(6498, v is ExplicitFieldOffsetStruct[], false);
             Eval(6499, v is ExplicitFieldOffsetStruct?, false);
@@ -6385,18 +6385,18 @@ internal class Program
             Eval(6518, v is ImplementTwoInterface[], false);
             Eval(6519, v is ImplementTwoInterface?, false);
             Eval(6520, v is ImplementTwoInterface?[], false);
-            Eval(6521, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(6522, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(6523, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(6524, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(6525, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(6526, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(6527, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(6528, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(6529, v is ImplementAllInterface<int>, false);
-            Eval(6530, v is ImplementAllInterface<int>[], false);
-            Eval(6531, v is ImplementAllInterface<int>?, false);
-            Eval(6532, v is ImplementAllInterface<int>?[], false);
+//            Eval(6521, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(6522, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(6523, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(6524, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(6525, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(6526, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(6527, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(6528, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(6529, v is ImplementAllInterface<int>, false);
+//            Eval(6530, v is ImplementAllInterface<int>[], false);
+//            Eval(6531, v is ImplementAllInterface<int>?, false);
+//            Eval(6532, v is ImplementAllInterface<int>?[], false);
             Eval(6533, v is IntE, false);
             Eval(6534, v is IntE[], false);
             Eval(6535, v is IntE?, false);
@@ -6495,38 +6495,38 @@ internal class Program
             Eval(6628, v is IEmpty[], false);
             Eval(6629, v is INotEmpty, false);
             Eval(6630, v is INotEmpty[], false);
-            Eval(6631, v is IEmptyGen<int>, false);
-            Eval(6632, v is IEmptyGen<int>[], false);
-            Eval(6633, v is INotEmptyGen<int>, false);
-            Eval(6634, v is INotEmptyGen<int>[], false);
+//            Eval(6631, v is IEmptyGen<int>, false);
+//            Eval(6632, v is IEmptyGen<int>[], false);
+//            Eval(6633, v is INotEmptyGen<int>, false);
+//            Eval(6634, v is INotEmptyGen<int>[], false);
             Eval(6635, v is SimpleDelegate, false);
             Eval(6636, v is SimpleDelegate[], false);
-            Eval(6637, v is GenericDelegate<int>, false);
-            Eval(6638, v is GenericDelegate<int>[], false);
+//            Eval(6637, v is GenericDelegate<int>, false);
+//            Eval(6638, v is GenericDelegate<int>[], false);
             Eval(6639, v is EmptyClass, false);
             Eval(6640, v is EmptyClass[], false);
             Eval(6641, v is NotEmptyClass, false);
             Eval(6642, v is NotEmptyClass[], false);
-            Eval(6643, v is EmptyClassGen<int>, false);
-            Eval(6644, v is EmptyClassGen<int>[], false);
-            Eval(6645, v is NotEmptyClassGen<Guid>, false);
-            Eval(6646, v is NotEmptyClassGen<Guid>[], false);
-            Eval(6647, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(6648, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(6643, v is EmptyClassGen<int>, false);
+//            Eval(6644, v is EmptyClassGen<int>[], false);
+//            Eval(6645, v is NotEmptyClassGen<Guid>, false);
+//            Eval(6646, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(6647, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(6648, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(6649, v is NestedClass, false);
             Eval(6650, v is NestedClass[], false);
-            Eval(6651, v is NestedClassGen<Decimal>, false);
-            Eval(6652, v is NestedClassGen<Decimal>[], false);
+//            Eval(6651, v is NestedClassGen<Decimal>, false);
+//            Eval(6652, v is NestedClassGen<Decimal>[], false);
             Eval(6653, v is ImplementOneInterfaceC, false);
             Eval(6654, v is ImplementOneInterfaceC[], false);
             Eval(6655, v is ImplementTwoInterfaceC, false);
             Eval(6656, v is ImplementTwoInterfaceC[], false);
-            Eval(6657, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(6658, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(6659, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(6660, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(6661, v is ImplementAllInterfaceC<int>, false);
-            Eval(6662, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(6657, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(6658, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(6659, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(6660, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(6661, v is ImplementAllInterfaceC<int>, false);
+//            Eval(6662, v is ImplementAllInterfaceC<int>[], false);
             Eval(6663, v is SealedClass, false);
             Eval(6664, v is SealedClass[], false);
         }
@@ -6540,26 +6540,26 @@ internal class Program
             Eval(6670, v is NotEmptyStruct[], false);
             Eval(6671, v is NotEmptyStruct?, false);
             Eval(6672, v is NotEmptyStruct?[], false);
-            Eval(6673, v is EmptyStructGen<int>, false);
-            Eval(6674, v is EmptyStructGen<int>[], false);
-            Eval(6675, v is EmptyStructGen<int>?, false);
-            Eval(6676, v is EmptyStructGen<int>?[], false);
-            Eval(6677, v is NotEmptyStructGen<Guid>, false);
-            Eval(6678, v is NotEmptyStructGen<Guid>[], false);
-            Eval(6679, v is NotEmptyStructGen<Guid>?, false);
-            Eval(6680, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(6681, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(6682, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(6683, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(6684, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(6673, v is EmptyStructGen<int>, false);
+//            Eval(6674, v is EmptyStructGen<int>[], false);
+//            Eval(6675, v is EmptyStructGen<int>?, false);
+//            Eval(6676, v is EmptyStructGen<int>?[], false);
+//            Eval(6677, v is NotEmptyStructGen<Guid>, false);
+//            Eval(6678, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(6679, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(6680, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(6681, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(6682, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(6683, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(6684, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(6685, v is NestedStruct, false);
             Eval(6686, v is NestedStruct[], false);
             Eval(6687, v is NestedStruct?, false);
             Eval(6688, v is NestedStruct?[], false);
-            Eval(6689, v is NestedStructGen<Decimal>, false);
-            Eval(6690, v is NestedStructGen<Decimal>[], false);
-            Eval(6691, v is NestedStructGen<Decimal>?, false);
-            Eval(6692, v is NestedStructGen<Decimal>?[], true);
+//            Eval(6689, v is NestedStructGen<Decimal>, false);
+//            Eval(6690, v is NestedStructGen<Decimal>[], false);
+//            Eval(6691, v is NestedStructGen<Decimal>?, false);
+//            Eval(6692, v is NestedStructGen<Decimal>?[], true);
             Eval(6693, v is ExplicitFieldOffsetStruct, false);
             Eval(6694, v is ExplicitFieldOffsetStruct[], false);
             Eval(6695, v is ExplicitFieldOffsetStruct?, false);
@@ -6576,18 +6576,18 @@ internal class Program
             Eval(6714, v is ImplementTwoInterface[], false);
             Eval(6715, v is ImplementTwoInterface?, false);
             Eval(6716, v is ImplementTwoInterface?[], false);
-            Eval(6717, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(6718, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(6719, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(6720, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(6721, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(6722, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(6723, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(6724, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(6725, v is ImplementAllInterface<int>, false);
-            Eval(6726, v is ImplementAllInterface<int>[], false);
-            Eval(6727, v is ImplementAllInterface<int>?, false);
-            Eval(6728, v is ImplementAllInterface<int>?[], false);
+//            Eval(6717, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(6718, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(6719, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(6720, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(6721, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(6722, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(6723, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(6724, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(6725, v is ImplementAllInterface<int>, false);
+//            Eval(6726, v is ImplementAllInterface<int>[], false);
+//            Eval(6727, v is ImplementAllInterface<int>?, false);
+//            Eval(6728, v is ImplementAllInterface<int>?[], false);
             Eval(6729, v is IntE, false);
             Eval(6730, v is IntE[], false);
             Eval(6731, v is IntE?, false);
@@ -6686,38 +6686,38 @@ internal class Program
             Eval(6824, v is IEmpty[], false);
             Eval(6825, v is INotEmpty, false);
             Eval(6826, v is INotEmpty[], false);
-            Eval(6827, v is IEmptyGen<int>, false);
-            Eval(6828, v is IEmptyGen<int>[], false);
-            Eval(6829, v is INotEmptyGen<int>, false);
-            Eval(6830, v is INotEmptyGen<int>[], false);
+//            Eval(6827, v is IEmptyGen<int>, false);
+//            Eval(6828, v is IEmptyGen<int>[], false);
+//            Eval(6829, v is INotEmptyGen<int>, false);
+//            Eval(6830, v is INotEmptyGen<int>[], false);
             Eval(6831, v is SimpleDelegate, false);
             Eval(6832, v is SimpleDelegate[], false);
-            Eval(6833, v is GenericDelegate<int>, false);
-            Eval(6834, v is GenericDelegate<int>[], false);
+//            Eval(6833, v is GenericDelegate<int>, false);
+//            Eval(6834, v is GenericDelegate<int>[], false);
             Eval(6835, v is EmptyClass, false);
             Eval(6836, v is EmptyClass[], false);
             Eval(6837, v is NotEmptyClass, false);
             Eval(6838, v is NotEmptyClass[], false);
-            Eval(6839, v is EmptyClassGen<int>, false);
-            Eval(6840, v is EmptyClassGen<int>[], false);
-            Eval(6841, v is NotEmptyClassGen<Guid>, false);
-            Eval(6842, v is NotEmptyClassGen<Guid>[], false);
-            Eval(6843, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(6844, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(6839, v is EmptyClassGen<int>, false);
+//            Eval(6840, v is EmptyClassGen<int>[], false);
+//            Eval(6841, v is NotEmptyClassGen<Guid>, false);
+//            Eval(6842, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(6843, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(6844, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(6845, v is NestedClass, false);
             Eval(6846, v is NestedClass[], false);
-            Eval(6847, v is NestedClassGen<Decimal>, false);
-            Eval(6848, v is NestedClassGen<Decimal>[], false);
+//            Eval(6847, v is NestedClassGen<Decimal>, false);
+//            Eval(6848, v is NestedClassGen<Decimal>[], false);
             Eval(6849, v is ImplementOneInterfaceC, false);
             Eval(6850, v is ImplementOneInterfaceC[], false);
             Eval(6851, v is ImplementTwoInterfaceC, false);
             Eval(6852, v is ImplementTwoInterfaceC[], false);
-            Eval(6853, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(6854, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(6855, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(6856, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(6857, v is ImplementAllInterfaceC<int>, false);
-            Eval(6858, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(6853, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(6854, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(6855, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(6856, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(6857, v is ImplementAllInterfaceC<int>, false);
+//            Eval(6858, v is ImplementAllInterfaceC<int>[], false);
             Eval(6859, v is SealedClass, false);
             Eval(6860, v is SealedClass[], false);
         }
@@ -6734,26 +6734,26 @@ internal class Program
             Eval(6866, v is NotEmptyStruct[], false);
             Eval(6867, v is NotEmptyStruct?, false);
             Eval(6868, v is NotEmptyStruct?[], false);
-            Eval(6869, v is EmptyStructGen<int>, false);
-            Eval(6870, v is EmptyStructGen<int>[], false);
-            Eval(6871, v is EmptyStructGen<int>?, false);
-            Eval(6872, v is EmptyStructGen<int>?[], false);
-            Eval(6873, v is NotEmptyStructGen<Guid>, false);
-            Eval(6874, v is NotEmptyStructGen<Guid>[], false);
-            Eval(6875, v is NotEmptyStructGen<Guid>?, false);
-            Eval(6876, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(6877, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(6878, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(6879, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(6880, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(6869, v is EmptyStructGen<int>, false);
+//            Eval(6870, v is EmptyStructGen<int>[], false);
+//            Eval(6871, v is EmptyStructGen<int>?, false);
+//            Eval(6872, v is EmptyStructGen<int>?[], false);
+//            Eval(6873, v is NotEmptyStructGen<Guid>, false);
+//            Eval(6874, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(6875, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(6876, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(6877, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(6878, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(6879, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(6880, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(6881, v is NestedStruct, false);
             Eval(6882, v is NestedStruct[], false);
             Eval(6883, v is NestedStruct?, false);
             Eval(6884, v is NestedStruct?[], false);
-            Eval(6885, v is NestedStructGen<Decimal>, false);
-            Eval(6886, v is NestedStructGen<Decimal>[], false);
-            Eval(6887, v is NestedStructGen<Decimal>?, false);
-            Eval(6888, v is NestedStructGen<Decimal>?[], false);
+//            Eval(6885, v is NestedStructGen<Decimal>, false);
+//            Eval(6886, v is NestedStructGen<Decimal>[], false);
+//            Eval(6887, v is NestedStructGen<Decimal>?, false);
+//            Eval(6888, v is NestedStructGen<Decimal>?[], false);
             Eval(6889, v is ExplicitFieldOffsetStruct, true);
             Eval(6890, v is ExplicitFieldOffsetStruct[], false);
             Eval(6891, v is ExplicitFieldOffsetStruct?, true);
@@ -6770,18 +6770,18 @@ internal class Program
             Eval(6910, v is ImplementTwoInterface[], false);
             Eval(6911, v is ImplementTwoInterface?, false);
             Eval(6912, v is ImplementTwoInterface?[], false);
-            Eval(6913, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(6914, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(6915, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(6916, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(6917, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(6918, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(6919, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(6920, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(6921, v is ImplementAllInterface<int>, false);
-            Eval(6922, v is ImplementAllInterface<int>[], false);
-            Eval(6923, v is ImplementAllInterface<int>?, false);
-            Eval(6924, v is ImplementAllInterface<int>?[], false);
+//            Eval(6913, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(6914, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(6915, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(6916, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(6917, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(6918, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(6919, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(6920, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(6921, v is ImplementAllInterface<int>, false);
+//            Eval(6922, v is ImplementAllInterface<int>[], false);
+//            Eval(6923, v is ImplementAllInterface<int>?, false);
+//            Eval(6924, v is ImplementAllInterface<int>?[], false);
             Eval(6925, v is IntE, false);
             Eval(6926, v is IntE[], false);
             Eval(6927, v is IntE?, false);
@@ -6880,38 +6880,38 @@ internal class Program
             Eval(7020, v is IEmpty[], false);
             Eval(7021, v is INotEmpty, false);
             Eval(7022, v is INotEmpty[], false);
-            Eval(7023, v is IEmptyGen<int>, false);
-            Eval(7024, v is IEmptyGen<int>[], false);
-            Eval(7025, v is INotEmptyGen<int>, false);
-            Eval(7026, v is INotEmptyGen<int>[], false);
+//            Eval(7023, v is IEmptyGen<int>, false);
+//            Eval(7024, v is IEmptyGen<int>[], false);
+//            Eval(7025, v is INotEmptyGen<int>, false);
+//            Eval(7026, v is INotEmptyGen<int>[], false);
             Eval(7027, v is SimpleDelegate, false);
             Eval(7028, v is SimpleDelegate[], false);
-            Eval(7029, v is GenericDelegate<int>, false);
-            Eval(7030, v is GenericDelegate<int>[], false);
+//            Eval(7029, v is GenericDelegate<int>, false);
+//            Eval(7030, v is GenericDelegate<int>[], false);
             Eval(7031, v is EmptyClass, false);
             Eval(7032, v is EmptyClass[], false);
             Eval(7033, v is NotEmptyClass, false);
             Eval(7034, v is NotEmptyClass[], false);
-            Eval(7035, v is EmptyClassGen<int>, false);
-            Eval(7036, v is EmptyClassGen<int>[], false);
-            Eval(7037, v is NotEmptyClassGen<Guid>, false);
-            Eval(7038, v is NotEmptyClassGen<Guid>[], false);
-            Eval(7039, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(7040, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(7035, v is EmptyClassGen<int>, false);
+//            Eval(7036, v is EmptyClassGen<int>[], false);
+//            Eval(7037, v is NotEmptyClassGen<Guid>, false);
+//            Eval(7038, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(7039, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(7040, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(7041, v is NestedClass, false);
             Eval(7042, v is NestedClass[], false);
-            Eval(7043, v is NestedClassGen<Decimal>, false);
-            Eval(7044, v is NestedClassGen<Decimal>[], false);
+//            Eval(7043, v is NestedClassGen<Decimal>, false);
+//            Eval(7044, v is NestedClassGen<Decimal>[], false);
             Eval(7045, v is ImplementOneInterfaceC, false);
             Eval(7046, v is ImplementOneInterfaceC[], false);
             Eval(7047, v is ImplementTwoInterfaceC, false);
             Eval(7048, v is ImplementTwoInterfaceC[], false);
-            Eval(7049, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(7050, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(7051, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(7052, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(7053, v is ImplementAllInterfaceC<int>, false);
-            Eval(7054, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(7049, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(7050, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(7051, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(7052, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(7053, v is ImplementAllInterfaceC<int>, false);
+//            Eval(7054, v is ImplementAllInterfaceC<int>[], false);
             Eval(7055, v is SealedClass, false);
             Eval(7056, v is SealedClass[], false);
         }
@@ -6925,26 +6925,26 @@ internal class Program
             Eval(7062, v is NotEmptyStruct[], false);
             Eval(7063, v is NotEmptyStruct?, false);
             Eval(7064, v is NotEmptyStruct?[], false);
-            Eval(7065, v is EmptyStructGen<int>, false);
-            Eval(7066, v is EmptyStructGen<int>[], false);
-            Eval(7067, v is EmptyStructGen<int>?, false);
-            Eval(7068, v is EmptyStructGen<int>?[], false);
-            Eval(7069, v is NotEmptyStructGen<Guid>, false);
-            Eval(7070, v is NotEmptyStructGen<Guid>[], false);
-            Eval(7071, v is NotEmptyStructGen<Guid>?, false);
-            Eval(7072, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(7073, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(7074, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(7075, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(7076, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(7065, v is EmptyStructGen<int>, false);
+//            Eval(7066, v is EmptyStructGen<int>[], false);
+//            Eval(7067, v is EmptyStructGen<int>?, false);
+//            Eval(7068, v is EmptyStructGen<int>?[], false);
+//            Eval(7069, v is NotEmptyStructGen<Guid>, false);
+//            Eval(7070, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(7071, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(7072, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(7073, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(7074, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(7075, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(7076, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(7077, v is NestedStruct, false);
             Eval(7078, v is NestedStruct[], false);
             Eval(7079, v is NestedStruct?, false);
             Eval(7080, v is NestedStruct?[], false);
-            Eval(7081, v is NestedStructGen<Decimal>, false);
-            Eval(7082, v is NestedStructGen<Decimal>[], false);
-            Eval(7083, v is NestedStructGen<Decimal>?, false);
-            Eval(7084, v is NestedStructGen<Decimal>?[], false);
+//            Eval(7081, v is NestedStructGen<Decimal>, false);
+//            Eval(7082, v is NestedStructGen<Decimal>[], false);
+//            Eval(7083, v is NestedStructGen<Decimal>?, false);
+//            Eval(7084, v is NestedStructGen<Decimal>?[], false);
             Eval(7085, v is ExplicitFieldOffsetStruct, true);
             Eval(7086, v is ExplicitFieldOffsetStruct[], false);
             Eval(7087, v is ExplicitFieldOffsetStruct?, true);
@@ -6961,18 +6961,18 @@ internal class Program
             Eval(7106, v is ImplementTwoInterface[], false);
             Eval(7107, v is ImplementTwoInterface?, false);
             Eval(7108, v is ImplementTwoInterface?[], false);
-            Eval(7109, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(7110, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(7111, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(7112, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(7113, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(7114, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(7115, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(7116, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(7117, v is ImplementAllInterface<int>, false);
-            Eval(7118, v is ImplementAllInterface<int>[], false);
-            Eval(7119, v is ImplementAllInterface<int>?, false);
-            Eval(7120, v is ImplementAllInterface<int>?[], false);
+//            Eval(7109, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(7110, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(7111, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(7112, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(7113, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(7114, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(7115, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(7116, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(7117, v is ImplementAllInterface<int>, false);
+//            Eval(7118, v is ImplementAllInterface<int>[], false);
+//            Eval(7119, v is ImplementAllInterface<int>?, false);
+//            Eval(7120, v is ImplementAllInterface<int>?[], false);
             Eval(7121, v is IntE, false);
             Eval(7122, v is IntE[], false);
             Eval(7123, v is IntE?, false);
@@ -7071,38 +7071,38 @@ internal class Program
             Eval(7216, v is IEmpty[], false);
             Eval(7217, v is INotEmpty, false);
             Eval(7218, v is INotEmpty[], false);
-            Eval(7219, v is IEmptyGen<int>, false);
-            Eval(7220, v is IEmptyGen<int>[], false);
-            Eval(7221, v is INotEmptyGen<int>, false);
-            Eval(7222, v is INotEmptyGen<int>[], false);
+//            Eval(7219, v is IEmptyGen<int>, false);
+//            Eval(7220, v is IEmptyGen<int>[], false);
+//            Eval(7221, v is INotEmptyGen<int>, false);
+//            Eval(7222, v is INotEmptyGen<int>[], false);
             Eval(7223, v is SimpleDelegate, false);
             Eval(7224, v is SimpleDelegate[], false);
-            Eval(7225, v is GenericDelegate<int>, false);
-            Eval(7226, v is GenericDelegate<int>[], false);
+//            Eval(7225, v is GenericDelegate<int>, false);
+//            Eval(7226, v is GenericDelegate<int>[], false);
             Eval(7227, v is EmptyClass, false);
             Eval(7228, v is EmptyClass[], false);
             Eval(7229, v is NotEmptyClass, false);
             Eval(7230, v is NotEmptyClass[], false);
-            Eval(7231, v is EmptyClassGen<int>, false);
-            Eval(7232, v is EmptyClassGen<int>[], false);
-            Eval(7233, v is NotEmptyClassGen<Guid>, false);
-            Eval(7234, v is NotEmptyClassGen<Guid>[], false);
-            Eval(7235, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(7236, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(7231, v is EmptyClassGen<int>, false);
+//            Eval(7232, v is EmptyClassGen<int>[], false);
+//            Eval(7233, v is NotEmptyClassGen<Guid>, false);
+//            Eval(7234, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(7235, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(7236, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(7237, v is NestedClass, false);
             Eval(7238, v is NestedClass[], false);
-            Eval(7239, v is NestedClassGen<Decimal>, false);
-            Eval(7240, v is NestedClassGen<Decimal>[], false);
+//            Eval(7239, v is NestedClassGen<Decimal>, false);
+//            Eval(7240, v is NestedClassGen<Decimal>[], false);
             Eval(7241, v is ImplementOneInterfaceC, false);
             Eval(7242, v is ImplementOneInterfaceC[], false);
             Eval(7243, v is ImplementTwoInterfaceC, false);
             Eval(7244, v is ImplementTwoInterfaceC[], false);
-            Eval(7245, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(7246, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(7247, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(7248, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(7249, v is ImplementAllInterfaceC<int>, false);
-            Eval(7250, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(7245, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(7246, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(7247, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(7248, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(7249, v is ImplementAllInterfaceC<int>, false);
+//            Eval(7250, v is ImplementAllInterfaceC<int>[], false);
             Eval(7251, v is SealedClass, false);
             Eval(7252, v is SealedClass[], false);
         }
@@ -7116,26 +7116,26 @@ internal class Program
             Eval(7258, v is NotEmptyStruct[], false);
             Eval(7259, v is NotEmptyStruct?, false);
             Eval(7260, v is NotEmptyStruct?[], false);
-            Eval(7261, v is EmptyStructGen<int>, false);
-            Eval(7262, v is EmptyStructGen<int>[], false);
-            Eval(7263, v is EmptyStructGen<int>?, false);
-            Eval(7264, v is EmptyStructGen<int>?[], false);
-            Eval(7265, v is NotEmptyStructGen<Guid>, false);
-            Eval(7266, v is NotEmptyStructGen<Guid>[], false);
-            Eval(7267, v is NotEmptyStructGen<Guid>?, false);
-            Eval(7268, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(7269, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(7270, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(7271, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(7272, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(7261, v is EmptyStructGen<int>, false);
+//            Eval(7262, v is EmptyStructGen<int>[], false);
+//            Eval(7263, v is EmptyStructGen<int>?, false);
+//            Eval(7264, v is EmptyStructGen<int>?[], false);
+//            Eval(7265, v is NotEmptyStructGen<Guid>, false);
+//            Eval(7266, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(7267, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(7268, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(7269, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(7270, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(7271, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(7272, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(7273, v is NestedStruct, false);
             Eval(7274, v is NestedStruct[], false);
             Eval(7275, v is NestedStruct?, false);
             Eval(7276, v is NestedStruct?[], false);
-            Eval(7277, v is NestedStructGen<Decimal>, false);
-            Eval(7278, v is NestedStructGen<Decimal>[], false);
-            Eval(7279, v is NestedStructGen<Decimal>?, false);
-            Eval(7280, v is NestedStructGen<Decimal>?[], false);
+//            Eval(7277, v is NestedStructGen<Decimal>, false);
+//            Eval(7278, v is NestedStructGen<Decimal>[], false);
+//            Eval(7279, v is NestedStructGen<Decimal>?, false);
+//            Eval(7280, v is NestedStructGen<Decimal>?[], false);
             Eval(7281, v is ExplicitFieldOffsetStruct, false);
             Eval(7282, v is ExplicitFieldOffsetStruct[], false);
             Eval(7283, v is ExplicitFieldOffsetStruct?, false);
@@ -7152,18 +7152,18 @@ internal class Program
             Eval(7302, v is ImplementTwoInterface[], false);
             Eval(7303, v is ImplementTwoInterface?, false);
             Eval(7304, v is ImplementTwoInterface?[], false);
-            Eval(7305, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(7306, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(7307, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(7308, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(7309, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(7310, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(7311, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(7312, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(7313, v is ImplementAllInterface<int>, false);
-            Eval(7314, v is ImplementAllInterface<int>[], false);
-            Eval(7315, v is ImplementAllInterface<int>?, false);
-            Eval(7316, v is ImplementAllInterface<int>?[], false);
+//            Eval(7305, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(7306, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(7307, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(7308, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(7309, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(7310, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(7311, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(7312, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(7313, v is ImplementAllInterface<int>, false);
+//            Eval(7314, v is ImplementAllInterface<int>[], false);
+//            Eval(7315, v is ImplementAllInterface<int>?, false);
+//            Eval(7316, v is ImplementAllInterface<int>?[], false);
             Eval(7317, v is IntE, false);
             Eval(7318, v is IntE[], false);
             Eval(7319, v is IntE?, false);
@@ -7262,38 +7262,38 @@ internal class Program
             Eval(7412, v is IEmpty[], false);
             Eval(7413, v is INotEmpty, false);
             Eval(7414, v is INotEmpty[], false);
-            Eval(7415, v is IEmptyGen<int>, false);
-            Eval(7416, v is IEmptyGen<int>[], false);
-            Eval(7417, v is INotEmptyGen<int>, false);
-            Eval(7418, v is INotEmptyGen<int>[], false);
+//            Eval(7415, v is IEmptyGen<int>, false);
+//            Eval(7416, v is IEmptyGen<int>[], false);
+//            Eval(7417, v is INotEmptyGen<int>, false);
+//            Eval(7418, v is INotEmptyGen<int>[], false);
             Eval(7419, v is SimpleDelegate, false);
             Eval(7420, v is SimpleDelegate[], false);
-            Eval(7421, v is GenericDelegate<int>, false);
-            Eval(7422, v is GenericDelegate<int>[], false);
+//            Eval(7421, v is GenericDelegate<int>, false);
+//            Eval(7422, v is GenericDelegate<int>[], false);
             Eval(7423, v is EmptyClass, false);
             Eval(7424, v is EmptyClass[], false);
             Eval(7425, v is NotEmptyClass, false);
             Eval(7426, v is NotEmptyClass[], false);
-            Eval(7427, v is EmptyClassGen<int>, false);
-            Eval(7428, v is EmptyClassGen<int>[], false);
-            Eval(7429, v is NotEmptyClassGen<Guid>, false);
-            Eval(7430, v is NotEmptyClassGen<Guid>[], false);
-            Eval(7431, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(7432, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(7427, v is EmptyClassGen<int>, false);
+//            Eval(7428, v is EmptyClassGen<int>[], false);
+//            Eval(7429, v is NotEmptyClassGen<Guid>, false);
+//            Eval(7430, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(7431, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(7432, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(7433, v is NestedClass, false);
             Eval(7434, v is NestedClass[], false);
-            Eval(7435, v is NestedClassGen<Decimal>, false);
-            Eval(7436, v is NestedClassGen<Decimal>[], false);
+//            Eval(7435, v is NestedClassGen<Decimal>, false);
+//            Eval(7436, v is NestedClassGen<Decimal>[], false);
             Eval(7437, v is ImplementOneInterfaceC, false);
             Eval(7438, v is ImplementOneInterfaceC[], false);
             Eval(7439, v is ImplementTwoInterfaceC, false);
             Eval(7440, v is ImplementTwoInterfaceC[], false);
-            Eval(7441, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(7442, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(7443, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(7444, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(7445, v is ImplementAllInterfaceC<int>, false);
-            Eval(7446, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(7441, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(7442, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(7443, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(7444, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(7445, v is ImplementAllInterfaceC<int>, false);
+//            Eval(7446, v is ImplementAllInterfaceC<int>[], false);
             Eval(7447, v is SealedClass, false);
             Eval(7448, v is SealedClass[], false);
         }
@@ -7307,26 +7307,26 @@ internal class Program
             Eval(7454, v is NotEmptyStruct[], false);
             Eval(7455, v is NotEmptyStruct?, false);
             Eval(7456, v is NotEmptyStruct?[], false);
-            Eval(7457, v is EmptyStructGen<int>, false);
-            Eval(7458, v is EmptyStructGen<int>[], false);
-            Eval(7459, v is EmptyStructGen<int>?, false);
-            Eval(7460, v is EmptyStructGen<int>?[], false);
-            Eval(7461, v is NotEmptyStructGen<Guid>, false);
-            Eval(7462, v is NotEmptyStructGen<Guid>[], false);
-            Eval(7463, v is NotEmptyStructGen<Guid>?, false);
-            Eval(7464, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(7465, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(7466, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(7467, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(7468, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(7457, v is EmptyStructGen<int>, false);
+//            Eval(7458, v is EmptyStructGen<int>[], false);
+//            Eval(7459, v is EmptyStructGen<int>?, false);
+//            Eval(7460, v is EmptyStructGen<int>?[], false);
+//            Eval(7461, v is NotEmptyStructGen<Guid>, false);
+//            Eval(7462, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(7463, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(7464, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(7465, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(7466, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(7467, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(7468, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(7469, v is NestedStruct, false);
             Eval(7470, v is NestedStruct[], false);
             Eval(7471, v is NestedStruct?, false);
             Eval(7472, v is NestedStruct?[], false);
-            Eval(7473, v is NestedStructGen<Decimal>, false);
-            Eval(7474, v is NestedStructGen<Decimal>[], false);
-            Eval(7475, v is NestedStructGen<Decimal>?, false);
-            Eval(7476, v is NestedStructGen<Decimal>?[], false);
+//            Eval(7473, v is NestedStructGen<Decimal>, false);
+//            Eval(7474, v is NestedStructGen<Decimal>[], false);
+//            Eval(7475, v is NestedStructGen<Decimal>?, false);
+//            Eval(7476, v is NestedStructGen<Decimal>?[], false);
             Eval(7477, v is ExplicitFieldOffsetStruct, false);
             Eval(7478, v is ExplicitFieldOffsetStruct[], false);
             Eval(7479, v is ExplicitFieldOffsetStruct?, false);
@@ -7343,18 +7343,18 @@ internal class Program
             Eval(7498, v is ImplementTwoInterface[], false);
             Eval(7499, v is ImplementTwoInterface?, false);
             Eval(7500, v is ImplementTwoInterface?[], false);
-            Eval(7501, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(7502, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(7503, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(7504, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(7505, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(7506, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(7507, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(7508, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(7509, v is ImplementAllInterface<int>, false);
-            Eval(7510, v is ImplementAllInterface<int>[], false);
-            Eval(7511, v is ImplementAllInterface<int>?, false);
-            Eval(7512, v is ImplementAllInterface<int>?[], false);
+//            Eval(7501, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(7502, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(7503, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(7504, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(7505, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(7506, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(7507, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(7508, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(7509, v is ImplementAllInterface<int>, false);
+//            Eval(7510, v is ImplementAllInterface<int>[], false);
+//            Eval(7511, v is ImplementAllInterface<int>?, false);
+//            Eval(7512, v is ImplementAllInterface<int>?[], false);
             Eval(7513, v is IntE, false);
             Eval(7514, v is IntE[], false);
             Eval(7515, v is IntE?, false);
@@ -7453,38 +7453,38 @@ internal class Program
             Eval(7608, v is IEmpty[], false);
             Eval(7609, v is INotEmpty, false);
             Eval(7610, v is INotEmpty[], false);
-            Eval(7611, v is IEmptyGen<int>, false);
-            Eval(7612, v is IEmptyGen<int>[], false);
-            Eval(7613, v is INotEmptyGen<int>, false);
-            Eval(7614, v is INotEmptyGen<int>[], false);
+//            Eval(7611, v is IEmptyGen<int>, false);
+//            Eval(7612, v is IEmptyGen<int>[], false);
+//            Eval(7613, v is INotEmptyGen<int>, false);
+//            Eval(7614, v is INotEmptyGen<int>[], false);
             Eval(7615, v is SimpleDelegate, false);
             Eval(7616, v is SimpleDelegate[], false);
-            Eval(7617, v is GenericDelegate<int>, false);
-            Eval(7618, v is GenericDelegate<int>[], false);
+//            Eval(7617, v is GenericDelegate<int>, false);
+//            Eval(7618, v is GenericDelegate<int>[], false);
             Eval(7619, v is EmptyClass, false);
             Eval(7620, v is EmptyClass[], false);
             Eval(7621, v is NotEmptyClass, false);
             Eval(7622, v is NotEmptyClass[], false);
-            Eval(7623, v is EmptyClassGen<int>, false);
-            Eval(7624, v is EmptyClassGen<int>[], false);
-            Eval(7625, v is NotEmptyClassGen<Guid>, false);
-            Eval(7626, v is NotEmptyClassGen<Guid>[], false);
-            Eval(7627, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(7628, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(7623, v is EmptyClassGen<int>, false);
+//            Eval(7624, v is EmptyClassGen<int>[], false);
+//            Eval(7625, v is NotEmptyClassGen<Guid>, false);
+//            Eval(7626, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(7627, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(7628, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(7629, v is NestedClass, false);
             Eval(7630, v is NestedClass[], false);
-            Eval(7631, v is NestedClassGen<Decimal>, false);
-            Eval(7632, v is NestedClassGen<Decimal>[], false);
+//            Eval(7631, v is NestedClassGen<Decimal>, false);
+//            Eval(7632, v is NestedClassGen<Decimal>[], false);
             Eval(7633, v is ImplementOneInterfaceC, false);
             Eval(7634, v is ImplementOneInterfaceC[], false);
             Eval(7635, v is ImplementTwoInterfaceC, false);
             Eval(7636, v is ImplementTwoInterfaceC[], false);
-            Eval(7637, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(7638, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(7639, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(7640, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(7641, v is ImplementAllInterfaceC<int>, false);
-            Eval(7642, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(7637, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(7638, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(7639, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(7640, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(7641, v is ImplementAllInterfaceC<int>, false);
+//            Eval(7642, v is ImplementAllInterfaceC<int>[], false);
             Eval(7643, v is SealedClass, false);
             Eval(7644, v is SealedClass[], false);
         }
@@ -7498,26 +7498,26 @@ internal class Program
             Eval(7650, v is NotEmptyStruct[], false);
             Eval(7651, v is NotEmptyStruct?, false);
             Eval(7652, v is NotEmptyStruct?[], false);
-            Eval(7653, v is EmptyStructGen<int>, false);
-            Eval(7654, v is EmptyStructGen<int>[], false);
-            Eval(7655, v is EmptyStructGen<int>?, false);
-            Eval(7656, v is EmptyStructGen<int>?[], false);
-            Eval(7657, v is NotEmptyStructGen<Guid>, false);
-            Eval(7658, v is NotEmptyStructGen<Guid>[], false);
-            Eval(7659, v is NotEmptyStructGen<Guid>?, false);
-            Eval(7660, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(7661, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(7662, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(7663, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(7664, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(7653, v is EmptyStructGen<int>, false);
+//            Eval(7654, v is EmptyStructGen<int>[], false);
+//            Eval(7655, v is EmptyStructGen<int>?, false);
+//            Eval(7656, v is EmptyStructGen<int>?[], false);
+//            Eval(7657, v is NotEmptyStructGen<Guid>, false);
+//            Eval(7658, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(7659, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(7660, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(7661, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(7662, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(7663, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(7664, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(7665, v is NestedStruct, false);
             Eval(7666, v is NestedStruct[], false);
             Eval(7667, v is NestedStruct?, false);
             Eval(7668, v is NestedStruct?[], false);
-            Eval(7669, v is NestedStructGen<Decimal>, false);
-            Eval(7670, v is NestedStructGen<Decimal>[], false);
-            Eval(7671, v is NestedStructGen<Decimal>?, false);
-            Eval(7672, v is NestedStructGen<Decimal>?[], false);
+//            Eval(7669, v is NestedStructGen<Decimal>, false);
+//            Eval(7670, v is NestedStructGen<Decimal>[], false);
+//            Eval(7671, v is NestedStructGen<Decimal>?, false);
+//            Eval(7672, v is NestedStructGen<Decimal>?[], false);
             Eval(7673, v is ExplicitFieldOffsetStruct, false);
             Eval(7674, v is ExplicitFieldOffsetStruct[], false);
             Eval(7675, v is ExplicitFieldOffsetStruct?, false);
@@ -7534,18 +7534,18 @@ internal class Program
             Eval(7694, v is ImplementTwoInterface[], false);
             Eval(7695, v is ImplementTwoInterface?, false);
             Eval(7696, v is ImplementTwoInterface?[], false);
-            Eval(7697, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(7698, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(7699, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(7700, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(7701, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(7702, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(7703, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(7704, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(7705, v is ImplementAllInterface<int>, false);
-            Eval(7706, v is ImplementAllInterface<int>[], false);
-            Eval(7707, v is ImplementAllInterface<int>?, false);
-            Eval(7708, v is ImplementAllInterface<int>?[], false);
+//            Eval(7697, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(7698, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(7699, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(7700, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(7701, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(7702, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(7703, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(7704, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(7705, v is ImplementAllInterface<int>, false);
+//            Eval(7706, v is ImplementAllInterface<int>[], false);
+//            Eval(7707, v is ImplementAllInterface<int>?, false);
+//            Eval(7708, v is ImplementAllInterface<int>?[], false);
             Eval(7709, v is IntE, false);
             Eval(7710, v is IntE[], false);
             Eval(7711, v is IntE?, false);
@@ -7644,38 +7644,38 @@ internal class Program
             Eval(7804, v is IEmpty[], false);
             Eval(7805, v is INotEmpty, false);
             Eval(7806, v is INotEmpty[], false);
-            Eval(7807, v is IEmptyGen<int>, false);
-            Eval(7808, v is IEmptyGen<int>[], false);
-            Eval(7809, v is INotEmptyGen<int>, false);
-            Eval(7810, v is INotEmptyGen<int>[], false);
+//            Eval(7807, v is IEmptyGen<int>, false);
+//            Eval(7808, v is IEmptyGen<int>[], false);
+//            Eval(7809, v is INotEmptyGen<int>, false);
+//            Eval(7810, v is INotEmptyGen<int>[], false);
             Eval(7811, v is SimpleDelegate, false);
             Eval(7812, v is SimpleDelegate[], false);
-            Eval(7813, v is GenericDelegate<int>, false);
-            Eval(7814, v is GenericDelegate<int>[], false);
+//            Eval(7813, v is GenericDelegate<int>, false);
+//            Eval(7814, v is GenericDelegate<int>[], false);
             Eval(7815, v is EmptyClass, false);
             Eval(7816, v is EmptyClass[], false);
             Eval(7817, v is NotEmptyClass, false);
             Eval(7818, v is NotEmptyClass[], false);
-            Eval(7819, v is EmptyClassGen<int>, false);
-            Eval(7820, v is EmptyClassGen<int>[], false);
-            Eval(7821, v is NotEmptyClassGen<Guid>, false);
-            Eval(7822, v is NotEmptyClassGen<Guid>[], false);
-            Eval(7823, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(7824, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(7819, v is EmptyClassGen<int>, false);
+//            Eval(7820, v is EmptyClassGen<int>[], false);
+//            Eval(7821, v is NotEmptyClassGen<Guid>, false);
+//            Eval(7822, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(7823, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(7824, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(7825, v is NestedClass, false);
             Eval(7826, v is NestedClass[], false);
-            Eval(7827, v is NestedClassGen<Decimal>, false);
-            Eval(7828, v is NestedClassGen<Decimal>[], false);
+//            Eval(7827, v is NestedClassGen<Decimal>, false);
+//            Eval(7828, v is NestedClassGen<Decimal>[], false);
             Eval(7829, v is ImplementOneInterfaceC, false);
             Eval(7830, v is ImplementOneInterfaceC[], false);
             Eval(7831, v is ImplementTwoInterfaceC, false);
             Eval(7832, v is ImplementTwoInterfaceC[], false);
-            Eval(7833, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(7834, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(7835, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(7836, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(7837, v is ImplementAllInterfaceC<int>, false);
-            Eval(7838, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(7833, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(7834, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(7835, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(7836, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(7837, v is ImplementAllInterfaceC<int>, false);
+//            Eval(7838, v is ImplementAllInterfaceC<int>[], false);
             Eval(7839, v is SealedClass, false);
             Eval(7840, v is SealedClass[], false);
         }
@@ -7692,26 +7692,26 @@ internal class Program
             Eval(9806, v is NotEmptyStruct[], false);
             Eval(9807, v is NotEmptyStruct?, false);
             Eval(9808, v is NotEmptyStruct?[], false);
-            Eval(9809, v is EmptyStructGen<int>, false);
-            Eval(9810, v is EmptyStructGen<int>[], false);
-            Eval(9811, v is EmptyStructGen<int>?, false);
-            Eval(9812, v is EmptyStructGen<int>?[], false);
-            Eval(9813, v is NotEmptyStructGen<Guid>, false);
-            Eval(9814, v is NotEmptyStructGen<Guid>[], false);
-            Eval(9815, v is NotEmptyStructGen<Guid>?, false);
-            Eval(9816, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(9817, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(9818, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(9819, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(9820, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(9809, v is EmptyStructGen<int>, false);
+//            Eval(9810, v is EmptyStructGen<int>[], false);
+//            Eval(9811, v is EmptyStructGen<int>?, false);
+//            Eval(9812, v is EmptyStructGen<int>?[], false);
+//            Eval(9813, v is NotEmptyStructGen<Guid>, false);
+//            Eval(9814, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(9815, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(9816, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(9817, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(9818, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(9819, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(9820, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(9821, v is NestedStruct, false);
             Eval(9822, v is NestedStruct[], false);
             Eval(9823, v is NestedStruct?, false);
             Eval(9824, v is NestedStruct?[], false);
-            Eval(9825, v is NestedStructGen<Decimal>, false);
-            Eval(9826, v is NestedStructGen<Decimal>[], false);
-            Eval(9827, v is NestedStructGen<Decimal>?, false);
-            Eval(9828, v is NestedStructGen<Decimal>?[], false);
+//            Eval(9825, v is NestedStructGen<Decimal>, false);
+//            Eval(9826, v is NestedStructGen<Decimal>[], false);
+//            Eval(9827, v is NestedStructGen<Decimal>?, false);
+//            Eval(9828, v is NestedStructGen<Decimal>?[], false);
             Eval(9829, v is ExplicitFieldOffsetStruct, false);
             Eval(9830, v is ExplicitFieldOffsetStruct[], false);
             Eval(9831, v is ExplicitFieldOffsetStruct?, false);
@@ -7728,18 +7728,18 @@ internal class Program
             Eval(9850, v is ImplementTwoInterface[], false);
             Eval(9851, v is ImplementTwoInterface?, false);
             Eval(9852, v is ImplementTwoInterface?[], false);
-            Eval(9853, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(9854, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(9855, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(9856, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(9857, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(9858, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(9859, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(9860, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(9861, v is ImplementAllInterface<int>, false);
-            Eval(9862, v is ImplementAllInterface<int>[], false);
-            Eval(9863, v is ImplementAllInterface<int>?, false);
-            Eval(9864, v is ImplementAllInterface<int>?[], false);
+//            Eval(9853, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(9854, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(9855, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(9856, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(9857, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(9858, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(9859, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(9860, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(9861, v is ImplementAllInterface<int>, false);
+//            Eval(9862, v is ImplementAllInterface<int>[], false);
+//            Eval(9863, v is ImplementAllInterface<int>?, false);
+//            Eval(9864, v is ImplementAllInterface<int>?[], false);
             Eval(9865, v is IntE, false);
             Eval(9866, v is IntE[], false);
             Eval(9867, v is IntE?, false);
@@ -7838,38 +7838,38 @@ internal class Program
             Eval(9960, v is IEmpty[], false);
             Eval(9961, v is INotEmpty, false);
             Eval(9962, v is INotEmpty[], false);
-            Eval(9963, v is IEmptyGen<int>, false);
-            Eval(9964, v is IEmptyGen<int>[], false);
-            Eval(9965, v is INotEmptyGen<int>, false);
-            Eval(9966, v is INotEmptyGen<int>[], false);
+//            Eval(9963, v is IEmptyGen<int>, false);
+//            Eval(9964, v is IEmptyGen<int>[], false);
+//            Eval(9965, v is INotEmptyGen<int>, false);
+//            Eval(9966, v is INotEmptyGen<int>[], false);
             Eval(9967, v is SimpleDelegate, false);
             Eval(9968, v is SimpleDelegate[], false);
-            Eval(9969, v is GenericDelegate<int>, false);
-            Eval(9970, v is GenericDelegate<int>[], false);
+//            Eval(9969, v is GenericDelegate<int>, false);
+//            Eval(9970, v is GenericDelegate<int>[], false);
             Eval(9971, v is EmptyClass, false);
             Eval(9972, v is EmptyClass[], false);
             Eval(9973, v is NotEmptyClass, false);
             Eval(9974, v is NotEmptyClass[], false);
-            Eval(9975, v is EmptyClassGen<int>, false);
-            Eval(9976, v is EmptyClassGen<int>[], false);
-            Eval(9977, v is NotEmptyClassGen<Guid>, false);
-            Eval(9978, v is NotEmptyClassGen<Guid>[], false);
-            Eval(9979, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(9980, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(9975, v is EmptyClassGen<int>, false);
+//            Eval(9976, v is EmptyClassGen<int>[], false);
+//            Eval(9977, v is NotEmptyClassGen<Guid>, false);
+//            Eval(9978, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(9979, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(9980, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(9981, v is NestedClass, false);
             Eval(9982, v is NestedClass[], false);
-            Eval(9983, v is NestedClassGen<Decimal>, false);
-            Eval(9984, v is NestedClassGen<Decimal>[], false);
+//            Eval(9983, v is NestedClassGen<Decimal>, false);
+//            Eval(9984, v is NestedClassGen<Decimal>[], false);
             Eval(9985, v is ImplementOneInterfaceC, false);
             Eval(9986, v is ImplementOneInterfaceC[], false);
             Eval(9987, v is ImplementTwoInterfaceC, false);
             Eval(9988, v is ImplementTwoInterfaceC[], false);
-            Eval(9989, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(9990, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(9991, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(9992, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(9993, v is ImplementAllInterfaceC<int>, false);
-            Eval(9994, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(9989, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(9990, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(9991, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(9992, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(9993, v is ImplementAllInterfaceC<int>, false);
+//            Eval(9994, v is ImplementAllInterfaceC<int>[], false);
             Eval(9995, v is SealedClass, false);
             Eval(9996, v is SealedClass[], false);
         }
@@ -7883,26 +7883,26 @@ internal class Program
             Eval(10002, v is NotEmptyStruct[], false);
             Eval(10003, v is NotEmptyStruct?, false);
             Eval(10004, v is NotEmptyStruct?[], false);
-            Eval(10005, v is EmptyStructGen<int>, false);
-            Eval(10006, v is EmptyStructGen<int>[], false);
-            Eval(10007, v is EmptyStructGen<int>?, false);
-            Eval(10008, v is EmptyStructGen<int>?[], false);
-            Eval(10009, v is NotEmptyStructGen<Guid>, false);
-            Eval(10010, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10011, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10012, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10013, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10014, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10015, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10016, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10005, v is EmptyStructGen<int>, false);
+//            Eval(10006, v is EmptyStructGen<int>[], false);
+//            Eval(10007, v is EmptyStructGen<int>?, false);
+//            Eval(10008, v is EmptyStructGen<int>?[], false);
+//            Eval(10009, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10010, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10011, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10012, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10013, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10014, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10015, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10016, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10017, v is NestedStruct, false);
             Eval(10018, v is NestedStruct[], false);
             Eval(10019, v is NestedStruct?, false);
             Eval(10020, v is NestedStruct?[], false);
-            Eval(10021, v is NestedStructGen<Decimal>, false);
-            Eval(10022, v is NestedStructGen<Decimal>[], false);
-            Eval(10023, v is NestedStructGen<Decimal>?, false);
-            Eval(10024, v is NestedStructGen<Decimal>?[], false);
+//            Eval(10021, v is NestedStructGen<Decimal>, false);
+//            Eval(10022, v is NestedStructGen<Decimal>[], false);
+//            Eval(10023, v is NestedStructGen<Decimal>?, false);
+//            Eval(10024, v is NestedStructGen<Decimal>?[], false);
             Eval(10025, v is ExplicitFieldOffsetStruct, false);
             Eval(10026, v is ExplicitFieldOffsetStruct[], false);
             Eval(10027, v is ExplicitFieldOffsetStruct?, false);
@@ -7919,18 +7919,18 @@ internal class Program
             Eval(10046, v is ImplementTwoInterface[], false);
             Eval(10047, v is ImplementTwoInterface?, false);
             Eval(10048, v is ImplementTwoInterface?[], false);
-            Eval(10049, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(10050, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(10051, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(10052, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(10053, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(10054, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(10055, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(10056, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(10057, v is ImplementAllInterface<int>, false);
-            Eval(10058, v is ImplementAllInterface<int>[], false);
-            Eval(10059, v is ImplementAllInterface<int>?, false);
-            Eval(10060, v is ImplementAllInterface<int>?[], false);
+//            Eval(10049, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(10050, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(10051, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(10052, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(10053, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(10054, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(10055, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(10056, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(10057, v is ImplementAllInterface<int>, false);
+//            Eval(10058, v is ImplementAllInterface<int>[], false);
+//            Eval(10059, v is ImplementAllInterface<int>?, false);
+//            Eval(10060, v is ImplementAllInterface<int>?[], false);
             Eval(10061, v is IntE, false);
             Eval(10062, v is IntE[], false);
             Eval(10063, v is IntE?, false);
@@ -8029,38 +8029,38 @@ internal class Program
             Eval(10156, v is IEmpty[], false);
             Eval(10157, v is INotEmpty, false);
             Eval(10158, v is INotEmpty[], false);
-            Eval(10159, v is IEmptyGen<int>, false);
-            Eval(10160, v is IEmptyGen<int>[], false);
-            Eval(10161, v is INotEmptyGen<int>, false);
-            Eval(10162, v is INotEmptyGen<int>[], false);
+//            Eval(10159, v is IEmptyGen<int>, false);
+//            Eval(10160, v is IEmptyGen<int>[], false);
+//            Eval(10161, v is INotEmptyGen<int>, false);
+//            Eval(10162, v is INotEmptyGen<int>[], false);
             Eval(10163, v is SimpleDelegate, false);
             Eval(10164, v is SimpleDelegate[], false);
-            Eval(10165, v is GenericDelegate<int>, false);
-            Eval(10166, v is GenericDelegate<int>[], false);
+//            Eval(10165, v is GenericDelegate<int>, false);
+//            Eval(10166, v is GenericDelegate<int>[], false);
             Eval(10167, v is EmptyClass, false);
             Eval(10168, v is EmptyClass[], false);
             Eval(10169, v is NotEmptyClass, false);
             Eval(10170, v is NotEmptyClass[], false);
-            Eval(10171, v is EmptyClassGen<int>, false);
-            Eval(10172, v is EmptyClassGen<int>[], false);
-            Eval(10173, v is NotEmptyClassGen<Guid>, false);
-            Eval(10174, v is NotEmptyClassGen<Guid>[], false);
-            Eval(10175, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(10176, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(10171, v is EmptyClassGen<int>, false);
+//            Eval(10172, v is EmptyClassGen<int>[], false);
+//            Eval(10173, v is NotEmptyClassGen<Guid>, false);
+//            Eval(10174, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(10175, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(10176, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(10177, v is NestedClass, false);
             Eval(10178, v is NestedClass[], false);
-            Eval(10179, v is NestedClassGen<Decimal>, false);
-            Eval(10180, v is NestedClassGen<Decimal>[], false);
+//            Eval(10179, v is NestedClassGen<Decimal>, false);
+//            Eval(10180, v is NestedClassGen<Decimal>[], false);
             Eval(10181, v is ImplementOneInterfaceC, false);
             Eval(10182, v is ImplementOneInterfaceC[], false);
             Eval(10183, v is ImplementTwoInterfaceC, false);
             Eval(10184, v is ImplementTwoInterfaceC[], false);
-            Eval(10185, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(10186, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(10187, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(10188, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(10189, v is ImplementAllInterfaceC<int>, false);
-            Eval(10190, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(10185, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(10186, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(10187, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(10188, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(10189, v is ImplementAllInterfaceC<int>, false);
+//            Eval(10190, v is ImplementAllInterfaceC<int>[], false);
             Eval(10191, v is SealedClass, false);
             Eval(10192, v is SealedClass[], false);
         }
@@ -8074,26 +8074,26 @@ internal class Program
             Eval(10198, v is NotEmptyStruct[], false);
             Eval(10199, v is NotEmptyStruct?, false);
             Eval(10200, v is NotEmptyStruct?[], false);
-            Eval(10201, v is EmptyStructGen<int>, false);
-            Eval(10202, v is EmptyStructGen<int>[], false);
-            Eval(10203, v is EmptyStructGen<int>?, false);
-            Eval(10204, v is EmptyStructGen<int>?[], false);
-            Eval(10205, v is NotEmptyStructGen<Guid>, false);
-            Eval(10206, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10207, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10208, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10209, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10210, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10211, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10212, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10201, v is EmptyStructGen<int>, false);
+//            Eval(10202, v is EmptyStructGen<int>[], false);
+//            Eval(10203, v is EmptyStructGen<int>?, false);
+//            Eval(10204, v is EmptyStructGen<int>?[], false);
+//            Eval(10205, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10206, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10207, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10208, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10209, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10210, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10211, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10212, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10213, v is NestedStruct, false);
             Eval(10214, v is NestedStruct[], false);
             Eval(10215, v is NestedStruct?, false);
             Eval(10216, v is NestedStruct?[], false);
-            Eval(10217, v is NestedStructGen<Decimal>, false);
-            Eval(10218, v is NestedStructGen<Decimal>[], false);
-            Eval(10219, v is NestedStructGen<Decimal>?, false);
-            Eval(10220, v is NestedStructGen<Decimal>?[], false);
+//            Eval(10217, v is NestedStructGen<Decimal>, false);
+//            Eval(10218, v is NestedStructGen<Decimal>[], false);
+//            Eval(10219, v is NestedStructGen<Decimal>?, false);
+//            Eval(10220, v is NestedStructGen<Decimal>?[], false);
             Eval(10221, v is ExplicitFieldOffsetStruct, false);
             Eval(10222, v is ExplicitFieldOffsetStruct[], false);
             Eval(10223, v is ExplicitFieldOffsetStruct?, false);
@@ -8110,18 +8110,18 @@ internal class Program
             Eval(10242, v is ImplementTwoInterface[], false);
             Eval(10243, v is ImplementTwoInterface?, false);
             Eval(10244, v is ImplementTwoInterface?[], false);
-            Eval(10245, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(10246, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(10247, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(10248, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(10249, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(10250, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(10251, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(10252, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(10253, v is ImplementAllInterface<int>, false);
-            Eval(10254, v is ImplementAllInterface<int>[], false);
-            Eval(10255, v is ImplementAllInterface<int>?, false);
-            Eval(10256, v is ImplementAllInterface<int>?[], false);
+//            Eval(10245, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(10246, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(10247, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(10248, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(10249, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(10250, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(10251, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(10252, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(10253, v is ImplementAllInterface<int>, false);
+//            Eval(10254, v is ImplementAllInterface<int>[], false);
+//            Eval(10255, v is ImplementAllInterface<int>?, false);
+//            Eval(10256, v is ImplementAllInterface<int>?[], false);
             Eval(10257, v is IntE, false);
             Eval(10258, v is IntE[], false);
             Eval(10259, v is IntE?, false);
@@ -8220,38 +8220,38 @@ internal class Program
             Eval(10352, v is IEmpty[], false);
             Eval(10353, v is INotEmpty, false);
             Eval(10354, v is INotEmpty[], false);
-            Eval(10355, v is IEmptyGen<int>, false);
-            Eval(10356, v is IEmptyGen<int>[], false);
-            Eval(10357, v is INotEmptyGen<int>, false);
-            Eval(10358, v is INotEmptyGen<int>[], false);
+//            Eval(10355, v is IEmptyGen<int>, false);
+//            Eval(10356, v is IEmptyGen<int>[], false);
+//            Eval(10357, v is INotEmptyGen<int>, false);
+//            Eval(10358, v is INotEmptyGen<int>[], false);
             Eval(10359, v is SimpleDelegate, false);
             Eval(10360, v is SimpleDelegate[], false);
-            Eval(10361, v is GenericDelegate<int>, false);
-            Eval(10362, v is GenericDelegate<int>[], false);
+//            Eval(10361, v is GenericDelegate<int>, false);
+//            Eval(10362, v is GenericDelegate<int>[], false);
             Eval(10363, v is EmptyClass, false);
             Eval(10364, v is EmptyClass[], false);
             Eval(10365, v is NotEmptyClass, false);
             Eval(10366, v is NotEmptyClass[], false);
-            Eval(10367, v is EmptyClassGen<int>, false);
-            Eval(10368, v is EmptyClassGen<int>[], false);
-            Eval(10369, v is NotEmptyClassGen<Guid>, false);
-            Eval(10370, v is NotEmptyClassGen<Guid>[], false);
-            Eval(10371, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(10372, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(10367, v is EmptyClassGen<int>, false);
+//            Eval(10368, v is EmptyClassGen<int>[], false);
+//            Eval(10369, v is NotEmptyClassGen<Guid>, false);
+//            Eval(10370, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(10371, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(10372, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(10373, v is NestedClass, false);
             Eval(10374, v is NestedClass[], false);
-            Eval(10375, v is NestedClassGen<Decimal>, false);
-            Eval(10376, v is NestedClassGen<Decimal>[], false);
+//            Eval(10375, v is NestedClassGen<Decimal>, false);
+//            Eval(10376, v is NestedClassGen<Decimal>[], false);
             Eval(10377, v is ImplementOneInterfaceC, false);
             Eval(10378, v is ImplementOneInterfaceC[], false);
             Eval(10379, v is ImplementTwoInterfaceC, false);
             Eval(10380, v is ImplementTwoInterfaceC[], false);
-            Eval(10381, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(10382, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(10383, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(10384, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(10385, v is ImplementAllInterfaceC<int>, false);
-            Eval(10386, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(10381, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(10382, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(10383, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(10384, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(10385, v is ImplementAllInterfaceC<int>, false);
+//            Eval(10386, v is ImplementAllInterfaceC<int>[], false);
             Eval(10387, v is SealedClass, false);
             Eval(10388, v is SealedClass[], false);
         }
@@ -8265,26 +8265,26 @@ internal class Program
             Eval(10394, v is NotEmptyStruct[], false);
             Eval(10395, v is NotEmptyStruct?, false);
             Eval(10396, v is NotEmptyStruct?[], false);
-            Eval(10397, v is EmptyStructGen<int>, false);
-            Eval(10398, v is EmptyStructGen<int>[], false);
-            Eval(10399, v is EmptyStructGen<int>?, false);
-            Eval(10400, v is EmptyStructGen<int>?[], false);
-            Eval(10401, v is NotEmptyStructGen<Guid>, false);
-            Eval(10402, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10403, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10404, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10405, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10406, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10407, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10408, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10397, v is EmptyStructGen<int>, false);
+//            Eval(10398, v is EmptyStructGen<int>[], false);
+//            Eval(10399, v is EmptyStructGen<int>?, false);
+//            Eval(10400, v is EmptyStructGen<int>?[], false);
+//            Eval(10401, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10402, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10403, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10404, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10405, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10406, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10407, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10408, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10409, v is NestedStruct, false);
             Eval(10410, v is NestedStruct[], false);
             Eval(10411, v is NestedStruct?, false);
             Eval(10412, v is NestedStruct?[], false);
-            Eval(10413, v is NestedStructGen<Decimal>, false);
-            Eval(10414, v is NestedStructGen<Decimal>[], false);
-            Eval(10415, v is NestedStructGen<Decimal>?, false);
-            Eval(10416, v is NestedStructGen<Decimal>?[], false);
+//            Eval(10413, v is NestedStructGen<Decimal>, false);
+//            Eval(10414, v is NestedStructGen<Decimal>[], false);
+//            Eval(10415, v is NestedStructGen<Decimal>?, false);
+//            Eval(10416, v is NestedStructGen<Decimal>?[], false);
             Eval(10417, v is ExplicitFieldOffsetStruct, false);
             Eval(10418, v is ExplicitFieldOffsetStruct[], false);
             Eval(10419, v is ExplicitFieldOffsetStruct?, false);
@@ -8301,18 +8301,18 @@ internal class Program
             Eval(10438, v is ImplementTwoInterface[], false);
             Eval(10439, v is ImplementTwoInterface?, false);
             Eval(10440, v is ImplementTwoInterface?[], false);
-            Eval(10441, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(10442, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(10443, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(10444, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(10445, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(10446, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(10447, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(10448, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(10449, v is ImplementAllInterface<int>, false);
-            Eval(10450, v is ImplementAllInterface<int>[], false);
-            Eval(10451, v is ImplementAllInterface<int>?, false);
-            Eval(10452, v is ImplementAllInterface<int>?[], false);
+//            Eval(10441, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(10442, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(10443, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(10444, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(10445, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(10446, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(10447, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(10448, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(10449, v is ImplementAllInterface<int>, false);
+//            Eval(10450, v is ImplementAllInterface<int>[], false);
+//            Eval(10451, v is ImplementAllInterface<int>?, false);
+//            Eval(10452, v is ImplementAllInterface<int>?[], false);
             Eval(10453, v is IntE, false);
             Eval(10454, v is IntE[], false);
             Eval(10455, v is IntE?, false);
@@ -8411,38 +8411,38 @@ internal class Program
             Eval(10548, v is IEmpty[], false);
             Eval(10549, v is INotEmpty, false);
             Eval(10550, v is INotEmpty[], false);
-            Eval(10551, v is IEmptyGen<int>, false);
-            Eval(10552, v is IEmptyGen<int>[], false);
-            Eval(10553, v is INotEmptyGen<int>, false);
-            Eval(10554, v is INotEmptyGen<int>[], false);
+//            Eval(10551, v is IEmptyGen<int>, false);
+//            Eval(10552, v is IEmptyGen<int>[], false);
+//            Eval(10553, v is INotEmptyGen<int>, false);
+//            Eval(10554, v is INotEmptyGen<int>[], false);
             Eval(10555, v is SimpleDelegate, false);
             Eval(10556, v is SimpleDelegate[], false);
-            Eval(10557, v is GenericDelegate<int>, false);
-            Eval(10558, v is GenericDelegate<int>[], false);
+//            Eval(10557, v is GenericDelegate<int>, false);
+//            Eval(10558, v is GenericDelegate<int>[], false);
             Eval(10559, v is EmptyClass, false);
             Eval(10560, v is EmptyClass[], false);
             Eval(10561, v is NotEmptyClass, false);
             Eval(10562, v is NotEmptyClass[], false);
-            Eval(10563, v is EmptyClassGen<int>, false);
-            Eval(10564, v is EmptyClassGen<int>[], false);
-            Eval(10565, v is NotEmptyClassGen<Guid>, false);
-            Eval(10566, v is NotEmptyClassGen<Guid>[], false);
-            Eval(10567, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(10568, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(10563, v is EmptyClassGen<int>, false);
+//            Eval(10564, v is EmptyClassGen<int>[], false);
+//            Eval(10565, v is NotEmptyClassGen<Guid>, false);
+//            Eval(10566, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(10567, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(10568, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(10569, v is NestedClass, false);
             Eval(10570, v is NestedClass[], false);
-            Eval(10571, v is NestedClassGen<Decimal>, false);
-            Eval(10572, v is NestedClassGen<Decimal>[], false);
+//            Eval(10571, v is NestedClassGen<Decimal>, false);
+//            Eval(10572, v is NestedClassGen<Decimal>[], false);
             Eval(10573, v is ImplementOneInterfaceC, false);
             Eval(10574, v is ImplementOneInterfaceC[], false);
             Eval(10575, v is ImplementTwoInterfaceC, false);
             Eval(10576, v is ImplementTwoInterfaceC[], false);
-            Eval(10577, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(10578, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(10579, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(10580, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(10581, v is ImplementAllInterfaceC<int>, false);
-            Eval(10582, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(10577, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(10578, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(10579, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(10580, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(10581, v is ImplementAllInterfaceC<int>, false);
+//            Eval(10582, v is ImplementAllInterfaceC<int>[], false);
             Eval(10583, v is SealedClass, false);
             Eval(10584, v is SealedClass[], false);
         }
@@ -8456,26 +8456,26 @@ internal class Program
             Eval(10590, v is NotEmptyStruct[], false);
             Eval(10591, v is NotEmptyStruct?, false);
             Eval(10592, v is NotEmptyStruct?[], false);
-            Eval(10593, v is EmptyStructGen<int>, false);
-            Eval(10594, v is EmptyStructGen<int>[], false);
-            Eval(10595, v is EmptyStructGen<int>?, false);
-            Eval(10596, v is EmptyStructGen<int>?[], false);
-            Eval(10597, v is NotEmptyStructGen<Guid>, false);
-            Eval(10598, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10599, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10600, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10601, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10602, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10603, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10604, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10593, v is EmptyStructGen<int>, false);
+//            Eval(10594, v is EmptyStructGen<int>[], false);
+//            Eval(10595, v is EmptyStructGen<int>?, false);
+//            Eval(10596, v is EmptyStructGen<int>?[], false);
+//            Eval(10597, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10598, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10599, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10600, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10601, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10602, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10603, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10604, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10605, v is NestedStruct, false);
             Eval(10606, v is NestedStruct[], false);
             Eval(10607, v is NestedStruct?, false);
             Eval(10608, v is NestedStruct?[], false);
-            Eval(10609, v is NestedStructGen<Decimal>, false);
-            Eval(10610, v is NestedStructGen<Decimal>[], false);
-            Eval(10611, v is NestedStructGen<Decimal>?, false);
-            Eval(10612, v is NestedStructGen<Decimal>?[], false);
+//            Eval(10609, v is NestedStructGen<Decimal>, false);
+//            Eval(10610, v is NestedStructGen<Decimal>[], false);
+//            Eval(10611, v is NestedStructGen<Decimal>?, false);
+//            Eval(10612, v is NestedStructGen<Decimal>?[], false);
             Eval(10613, v is ExplicitFieldOffsetStruct, false);
             Eval(10614, v is ExplicitFieldOffsetStruct[], false);
             Eval(10615, v is ExplicitFieldOffsetStruct?, false);
@@ -8492,18 +8492,18 @@ internal class Program
             Eval(10634, v is ImplementTwoInterface[], false);
             Eval(10635, v is ImplementTwoInterface?, false);
             Eval(10636, v is ImplementTwoInterface?[], false);
-            Eval(10637, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(10638, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(10639, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(10640, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(10641, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(10642, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(10643, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(10644, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(10645, v is ImplementAllInterface<int>, false);
-            Eval(10646, v is ImplementAllInterface<int>[], false);
-            Eval(10647, v is ImplementAllInterface<int>?, false);
-            Eval(10648, v is ImplementAllInterface<int>?[], false);
+//            Eval(10637, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(10638, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(10639, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(10640, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(10641, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(10642, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(10643, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(10644, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(10645, v is ImplementAllInterface<int>, false);
+//            Eval(10646, v is ImplementAllInterface<int>[], false);
+//            Eval(10647, v is ImplementAllInterface<int>?, false);
+//            Eval(10648, v is ImplementAllInterface<int>?[], false);
             Eval(10649, v is IntE, false);
             Eval(10650, v is IntE[], false);
             Eval(10651, v is IntE?, false);
@@ -8602,38 +8602,38 @@ internal class Program
             Eval(10744, v is IEmpty[], false);
             Eval(10745, v is INotEmpty, false);
             Eval(10746, v is INotEmpty[], false);
-            Eval(10747, v is IEmptyGen<int>, false);
-            Eval(10748, v is IEmptyGen<int>[], false);
-            Eval(10749, v is INotEmptyGen<int>, false);
-            Eval(10750, v is INotEmptyGen<int>[], false);
+//            Eval(10747, v is IEmptyGen<int>, false);
+//            Eval(10748, v is IEmptyGen<int>[], false);
+//            Eval(10749, v is INotEmptyGen<int>, false);
+//            Eval(10750, v is INotEmptyGen<int>[], false);
             Eval(10751, v is SimpleDelegate, false);
             Eval(10752, v is SimpleDelegate[], false);
-            Eval(10753, v is GenericDelegate<int>, false);
-            Eval(10754, v is GenericDelegate<int>[], false);
+//            Eval(10753, v is GenericDelegate<int>, false);
+//            Eval(10754, v is GenericDelegate<int>[], false);
             Eval(10755, v is EmptyClass, false);
             Eval(10756, v is EmptyClass[], false);
             Eval(10757, v is NotEmptyClass, false);
             Eval(10758, v is NotEmptyClass[], false);
-            Eval(10759, v is EmptyClassGen<int>, false);
-            Eval(10760, v is EmptyClassGen<int>[], false);
-            Eval(10761, v is NotEmptyClassGen<Guid>, false);
-            Eval(10762, v is NotEmptyClassGen<Guid>[], false);
-            Eval(10763, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(10764, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(10759, v is EmptyClassGen<int>, false);
+//            Eval(10760, v is EmptyClassGen<int>[], false);
+//            Eval(10761, v is NotEmptyClassGen<Guid>, false);
+//            Eval(10762, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(10763, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(10764, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(10765, v is NestedClass, false);
             Eval(10766, v is NestedClass[], false);
-            Eval(10767, v is NestedClassGen<Decimal>, false);
-            Eval(10768, v is NestedClassGen<Decimal>[], false);
+//            Eval(10767, v is NestedClassGen<Decimal>, false);
+//            Eval(10768, v is NestedClassGen<Decimal>[], false);
             Eval(10769, v is ImplementOneInterfaceC, false);
             Eval(10770, v is ImplementOneInterfaceC[], false);
             Eval(10771, v is ImplementTwoInterfaceC, false);
             Eval(10772, v is ImplementTwoInterfaceC[], false);
-            Eval(10773, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(10774, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(10775, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(10776, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(10777, v is ImplementAllInterfaceC<int>, false);
-            Eval(10778, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(10773, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(10774, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(10775, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(10776, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(10777, v is ImplementAllInterfaceC<int>, false);
+//            Eval(10778, v is ImplementAllInterfaceC<int>[], false);
             Eval(10779, v is SealedClass, false);
             Eval(10780, v is SealedClass[], false);
         }
@@ -8650,26 +8650,26 @@ internal class Program
             Eval(10786, v is NotEmptyStruct[], false);
             Eval(10787, v is NotEmptyStruct?, false);
             Eval(10788, v is NotEmptyStruct?[], false);
-            Eval(10789, v is EmptyStructGen<int>, false);
-            Eval(10790, v is EmptyStructGen<int>[], false);
-            Eval(10791, v is EmptyStructGen<int>?, false);
-            Eval(10792, v is EmptyStructGen<int>?[], false);
-            Eval(10793, v is NotEmptyStructGen<Guid>, false);
-            Eval(10794, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10795, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10796, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10797, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10798, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10799, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10800, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10789, v is EmptyStructGen<int>, false);
+//            Eval(10790, v is EmptyStructGen<int>[], false);
+//            Eval(10791, v is EmptyStructGen<int>?, false);
+//            Eval(10792, v is EmptyStructGen<int>?[], false);
+//            Eval(10793, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10794, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10795, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10796, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10797, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10798, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10799, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10800, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10801, v is NestedStruct, false);
             Eval(10802, v is NestedStruct[], false);
             Eval(10803, v is NestedStruct?, false);
             Eval(10804, v is NestedStruct?[], false);
-            Eval(10805, v is NestedStructGen<Decimal>, false);
-            Eval(10806, v is NestedStructGen<Decimal>[], false);
-            Eval(10807, v is NestedStructGen<Decimal>?, false);
-            Eval(10808, v is NestedStructGen<Decimal>?[], false);
+//            Eval(10805, v is NestedStructGen<Decimal>, false);
+//            Eval(10806, v is NestedStructGen<Decimal>[], false);
+//            Eval(10807, v is NestedStructGen<Decimal>?, false);
+//            Eval(10808, v is NestedStructGen<Decimal>?[], false);
             Eval(10809, v is ExplicitFieldOffsetStruct, false);
             Eval(10810, v is ExplicitFieldOffsetStruct[], false);
             Eval(10811, v is ExplicitFieldOffsetStruct?, false);
@@ -8686,18 +8686,18 @@ internal class Program
             Eval(10830, v is ImplementTwoInterface[], false);
             Eval(10831, v is ImplementTwoInterface?, false);
             Eval(10832, v is ImplementTwoInterface?[], false);
-            Eval(10833, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(10834, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(10835, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(10836, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(10837, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(10838, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(10839, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(10840, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(10841, v is ImplementAllInterface<int>, false);
-            Eval(10842, v is ImplementAllInterface<int>[], false);
-            Eval(10843, v is ImplementAllInterface<int>?, false);
-            Eval(10844, v is ImplementAllInterface<int>?[], false);
+//            Eval(10833, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(10834, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(10835, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(10836, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(10837, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(10838, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(10839, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(10840, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(10841, v is ImplementAllInterface<int>, false);
+//            Eval(10842, v is ImplementAllInterface<int>[], false);
+//            Eval(10843, v is ImplementAllInterface<int>?, false);
+//            Eval(10844, v is ImplementAllInterface<int>?[], false);
             Eval(10845, v is IntE, false);
             Eval(10846, v is IntE[], false);
             Eval(10847, v is IntE?, false);
@@ -8796,38 +8796,38 @@ internal class Program
             Eval(10940, v is IEmpty[], false);
             Eval(10941, v is INotEmpty, false);
             Eval(10942, v is INotEmpty[], false);
-            Eval(10943, v is IEmptyGen<int>, false);
-            Eval(10944, v is IEmptyGen<int>[], false);
-            Eval(10945, v is INotEmptyGen<int>, false);
-            Eval(10946, v is INotEmptyGen<int>[], false);
+//            Eval(10943, v is IEmptyGen<int>, false);
+//            Eval(10944, v is IEmptyGen<int>[], false);
+//            Eval(10945, v is INotEmptyGen<int>, false);
+//            Eval(10946, v is INotEmptyGen<int>[], false);
             Eval(10947, v is SimpleDelegate, false);
             Eval(10948, v is SimpleDelegate[], false);
-            Eval(10949, v is GenericDelegate<int>, false);
-            Eval(10950, v is GenericDelegate<int>[], false);
+//            Eval(10949, v is GenericDelegate<int>, false);
+//            Eval(10950, v is GenericDelegate<int>[], false);
             Eval(10951, v is EmptyClass, false);
             Eval(10952, v is EmptyClass[], false);
             Eval(10953, v is NotEmptyClass, false);
             Eval(10954, v is NotEmptyClass[], false);
-            Eval(10955, v is EmptyClassGen<int>, false);
-            Eval(10956, v is EmptyClassGen<int>[], false);
-            Eval(10957, v is NotEmptyClassGen<Guid>, false);
-            Eval(10958, v is NotEmptyClassGen<Guid>[], false);
-            Eval(10959, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(10960, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(10955, v is EmptyClassGen<int>, false);
+//            Eval(10956, v is EmptyClassGen<int>[], false);
+//            Eval(10957, v is NotEmptyClassGen<Guid>, false);
+//            Eval(10958, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(10959, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(10960, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(10961, v is NestedClass, false);
             Eval(10962, v is NestedClass[], false);
-            Eval(10963, v is NestedClassGen<Decimal>, false);
-            Eval(10964, v is NestedClassGen<Decimal>[], false);
+//            Eval(10963, v is NestedClassGen<Decimal>, false);
+//            Eval(10964, v is NestedClassGen<Decimal>[], false);
             Eval(10965, v is ImplementOneInterfaceC, false);
             Eval(10966, v is ImplementOneInterfaceC[], false);
             Eval(10967, v is ImplementTwoInterfaceC, false);
             Eval(10968, v is ImplementTwoInterfaceC[], false);
-            Eval(10969, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(10970, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(10971, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(10972, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(10973, v is ImplementAllInterfaceC<int>, false);
-            Eval(10974, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(10969, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(10970, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(10971, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(10972, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(10973, v is ImplementAllInterfaceC<int>, false);
+//            Eval(10974, v is ImplementAllInterfaceC<int>[], false);
             Eval(10975, v is SealedClass, false);
             Eval(10976, v is SealedClass[], false);
         }
@@ -8841,26 +8841,26 @@ internal class Program
             Eval(10982, v is NotEmptyStruct[], false);
             Eval(10983, v is NotEmptyStruct?, false);
             Eval(10984, v is NotEmptyStruct?[], false);
-            Eval(10985, v is EmptyStructGen<int>, false);
-            Eval(10986, v is EmptyStructGen<int>[], false);
-            Eval(10987, v is EmptyStructGen<int>?, false);
-            Eval(10988, v is EmptyStructGen<int>?[], false);
-            Eval(10989, v is NotEmptyStructGen<Guid>, false);
-            Eval(10990, v is NotEmptyStructGen<Guid>[], false);
-            Eval(10991, v is NotEmptyStructGen<Guid>?, false);
-            Eval(10992, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(10993, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(10994, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(10995, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(10996, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(10985, v is EmptyStructGen<int>, false);
+//            Eval(10986, v is EmptyStructGen<int>[], false);
+//            Eval(10987, v is EmptyStructGen<int>?, false);
+//            Eval(10988, v is EmptyStructGen<int>?[], false);
+//            Eval(10989, v is NotEmptyStructGen<Guid>, false);
+//            Eval(10990, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(10991, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(10992, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(10993, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(10994, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(10995, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(10996, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(10997, v is NestedStruct, false);
             Eval(10998, v is NestedStruct[], false);
             Eval(10999, v is NestedStruct?, false);
             Eval(11000, v is NestedStruct?[], false);
-            Eval(11001, v is NestedStructGen<Decimal>, false);
-            Eval(11002, v is NestedStructGen<Decimal>[], false);
-            Eval(11003, v is NestedStructGen<Decimal>?, false);
-            Eval(11004, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11001, v is NestedStructGen<Decimal>, false);
+//            Eval(11002, v is NestedStructGen<Decimal>[], false);
+//            Eval(11003, v is NestedStructGen<Decimal>?, false);
+//            Eval(11004, v is NestedStructGen<Decimal>?[], false);
             Eval(11005, v is ExplicitFieldOffsetStruct, false);
             Eval(11006, v is ExplicitFieldOffsetStruct[], false);
             Eval(11007, v is ExplicitFieldOffsetStruct?, false);
@@ -8877,18 +8877,18 @@ internal class Program
             Eval(11026, v is ImplementTwoInterface[], false);
             Eval(11027, v is ImplementTwoInterface?, false);
             Eval(11028, v is ImplementTwoInterface?[], false);
-            Eval(11029, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(11030, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(11031, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(11032, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(11033, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(11034, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(11035, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(11036, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(11037, v is ImplementAllInterface<int>, false);
-            Eval(11038, v is ImplementAllInterface<int>[], false);
-            Eval(11039, v is ImplementAllInterface<int>?, false);
-            Eval(11040, v is ImplementAllInterface<int>?[], false);
+//            Eval(11029, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(11030, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(11031, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(11032, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(11033, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(11034, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(11035, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(11036, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(11037, v is ImplementAllInterface<int>, false);
+//            Eval(11038, v is ImplementAllInterface<int>[], false);
+//            Eval(11039, v is ImplementAllInterface<int>?, false);
+//            Eval(11040, v is ImplementAllInterface<int>?[], false);
             Eval(11041, v is IntE, false);
             Eval(11042, v is IntE[], false);
             Eval(11043, v is IntE?, false);
@@ -8987,38 +8987,38 @@ internal class Program
             Eval(11136, v is IEmpty[], false);
             Eval(11137, v is INotEmpty, false);
             Eval(11138, v is INotEmpty[], false);
-            Eval(11139, v is IEmptyGen<int>, false);
-            Eval(11140, v is IEmptyGen<int>[], false);
-            Eval(11141, v is INotEmptyGen<int>, false);
-            Eval(11142, v is INotEmptyGen<int>[], false);
+//            Eval(11139, v is IEmptyGen<int>, false);
+//            Eval(11140, v is IEmptyGen<int>[], false);
+//            Eval(11141, v is INotEmptyGen<int>, false);
+//            Eval(11142, v is INotEmptyGen<int>[], false);
             Eval(11143, v is SimpleDelegate, false);
             Eval(11144, v is SimpleDelegate[], false);
-            Eval(11145, v is GenericDelegate<int>, false);
-            Eval(11146, v is GenericDelegate<int>[], false);
+//            Eval(11145, v is GenericDelegate<int>, false);
+//            Eval(11146, v is GenericDelegate<int>[], false);
             Eval(11147, v is EmptyClass, false);
             Eval(11148, v is EmptyClass[], false);
             Eval(11149, v is NotEmptyClass, false);
             Eval(11150, v is NotEmptyClass[], false);
-            Eval(11151, v is EmptyClassGen<int>, false);
-            Eval(11152, v is EmptyClassGen<int>[], false);
-            Eval(11153, v is NotEmptyClassGen<Guid>, false);
-            Eval(11154, v is NotEmptyClassGen<Guid>[], false);
-            Eval(11155, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(11156, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(11151, v is EmptyClassGen<int>, false);
+//            Eval(11152, v is EmptyClassGen<int>[], false);
+//            Eval(11153, v is NotEmptyClassGen<Guid>, false);
+//            Eval(11154, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(11155, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(11156, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(11157, v is NestedClass, false);
             Eval(11158, v is NestedClass[], false);
-            Eval(11159, v is NestedClassGen<Decimal>, false);
-            Eval(11160, v is NestedClassGen<Decimal>[], false);
+//            Eval(11159, v is NestedClassGen<Decimal>, false);
+//            Eval(11160, v is NestedClassGen<Decimal>[], false);
             Eval(11161, v is ImplementOneInterfaceC, false);
             Eval(11162, v is ImplementOneInterfaceC[], false);
             Eval(11163, v is ImplementTwoInterfaceC, false);
             Eval(11164, v is ImplementTwoInterfaceC[], false);
-            Eval(11165, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(11166, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(11167, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(11168, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(11169, v is ImplementAllInterfaceC<int>, false);
-            Eval(11170, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(11165, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(11166, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(11167, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(11168, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(11169, v is ImplementAllInterfaceC<int>, false);
+//            Eval(11170, v is ImplementAllInterfaceC<int>[], false);
             Eval(11171, v is SealedClass, false);
             Eval(11172, v is SealedClass[], false);
         }
@@ -9032,26 +9032,26 @@ internal class Program
             Eval(11178, v is NotEmptyStruct[], false);
             Eval(11179, v is NotEmptyStruct?, false);
             Eval(11180, v is NotEmptyStruct?[], false);
-            Eval(11181, v is EmptyStructGen<int>, false);
-            Eval(11182, v is EmptyStructGen<int>[], false);
-            Eval(11183, v is EmptyStructGen<int>?, false);
-            Eval(11184, v is EmptyStructGen<int>?[], false);
-            Eval(11185, v is NotEmptyStructGen<Guid>, false);
-            Eval(11186, v is NotEmptyStructGen<Guid>[], false);
-            Eval(11187, v is NotEmptyStructGen<Guid>?, false);
-            Eval(11188, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(11189, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(11190, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(11191, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(11192, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(11181, v is EmptyStructGen<int>, false);
+//            Eval(11182, v is EmptyStructGen<int>[], false);
+//            Eval(11183, v is EmptyStructGen<int>?, false);
+//            Eval(11184, v is EmptyStructGen<int>?[], false);
+//            Eval(11185, v is NotEmptyStructGen<Guid>, false);
+//            Eval(11186, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(11187, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(11188, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(11189, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(11190, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(11191, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(11192, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(11193, v is NestedStruct, false);
             Eval(11194, v is NestedStruct[], false);
             Eval(11195, v is NestedStruct?, false);
             Eval(11196, v is NestedStruct?[], false);
-            Eval(11197, v is NestedStructGen<Decimal>, false);
-            Eval(11198, v is NestedStructGen<Decimal>[], false);
-            Eval(11199, v is NestedStructGen<Decimal>?, false);
-            Eval(11200, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11197, v is NestedStructGen<Decimal>, false);
+//            Eval(11198, v is NestedStructGen<Decimal>[], false);
+//            Eval(11199, v is NestedStructGen<Decimal>?, false);
+//            Eval(11200, v is NestedStructGen<Decimal>?[], false);
             Eval(11201, v is ExplicitFieldOffsetStruct, false);
             Eval(11202, v is ExplicitFieldOffsetStruct[], false);
             Eval(11203, v is ExplicitFieldOffsetStruct?, false);
@@ -9068,18 +9068,18 @@ internal class Program
             Eval(11222, v is ImplementTwoInterface[], false);
             Eval(11223, v is ImplementTwoInterface?, false);
             Eval(11224, v is ImplementTwoInterface?[], false);
-            Eval(11225, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(11226, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(11227, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(11228, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(11229, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(11230, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(11231, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(11232, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(11233, v is ImplementAllInterface<int>, false);
-            Eval(11234, v is ImplementAllInterface<int>[], false);
-            Eval(11235, v is ImplementAllInterface<int>?, false);
-            Eval(11236, v is ImplementAllInterface<int>?[], false);
+//            Eval(11225, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(11226, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(11227, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(11228, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(11229, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(11230, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(11231, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(11232, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(11233, v is ImplementAllInterface<int>, false);
+//            Eval(11234, v is ImplementAllInterface<int>[], false);
+//            Eval(11235, v is ImplementAllInterface<int>?, false);
+//            Eval(11236, v is ImplementAllInterface<int>?[], false);
             Eval(11237, v is IntE, false);
             Eval(11238, v is IntE[], false);
             Eval(11239, v is IntE?, false);
@@ -9178,38 +9178,38 @@ internal class Program
             Eval(11332, v is IEmpty[], false);
             Eval(11333, v is INotEmpty, false);
             Eval(11334, v is INotEmpty[], false);
-            Eval(11335, v is IEmptyGen<int>, false);
-            Eval(11336, v is IEmptyGen<int>[], false);
-            Eval(11337, v is INotEmptyGen<int>, false);
-            Eval(11338, v is INotEmptyGen<int>[], false);
+//            Eval(11335, v is IEmptyGen<int>, false);
+//            Eval(11336, v is IEmptyGen<int>[], false);
+//            Eval(11337, v is INotEmptyGen<int>, false);
+//            Eval(11338, v is INotEmptyGen<int>[], false);
             Eval(11339, v is SimpleDelegate, false);
             Eval(11340, v is SimpleDelegate[], false);
-            Eval(11341, v is GenericDelegate<int>, false);
-            Eval(11342, v is GenericDelegate<int>[], false);
+//            Eval(11341, v is GenericDelegate<int>, false);
+//            Eval(11342, v is GenericDelegate<int>[], false);
             Eval(11343, v is EmptyClass, false);
             Eval(11344, v is EmptyClass[], false);
             Eval(11345, v is NotEmptyClass, false);
             Eval(11346, v is NotEmptyClass[], false);
-            Eval(11347, v is EmptyClassGen<int>, false);
-            Eval(11348, v is EmptyClassGen<int>[], false);
-            Eval(11349, v is NotEmptyClassGen<Guid>, false);
-            Eval(11350, v is NotEmptyClassGen<Guid>[], false);
-            Eval(11351, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(11352, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(11347, v is EmptyClassGen<int>, false);
+//            Eval(11348, v is EmptyClassGen<int>[], false);
+//            Eval(11349, v is NotEmptyClassGen<Guid>, false);
+//            Eval(11350, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(11351, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(11352, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(11353, v is NestedClass, false);
             Eval(11354, v is NestedClass[], false);
-            Eval(11355, v is NestedClassGen<Decimal>, false);
-            Eval(11356, v is NestedClassGen<Decimal>[], false);
+//            Eval(11355, v is NestedClassGen<Decimal>, false);
+//            Eval(11356, v is NestedClassGen<Decimal>[], false);
             Eval(11357, v is ImplementOneInterfaceC, false);
             Eval(11358, v is ImplementOneInterfaceC[], false);
             Eval(11359, v is ImplementTwoInterfaceC, false);
             Eval(11360, v is ImplementTwoInterfaceC[], false);
-            Eval(11361, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(11362, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(11363, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(11364, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(11365, v is ImplementAllInterfaceC<int>, false);
-            Eval(11366, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(11361, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(11362, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(11363, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(11364, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(11365, v is ImplementAllInterfaceC<int>, false);
+//            Eval(11366, v is ImplementAllInterfaceC<int>[], false);
             Eval(11367, v is SealedClass, false);
             Eval(11368, v is SealedClass[], false);
         }
@@ -9223,26 +9223,26 @@ internal class Program
             Eval(11374, v is NotEmptyStruct[], false);
             Eval(11375, v is NotEmptyStruct?, false);
             Eval(11376, v is NotEmptyStruct?[], false);
-            Eval(11377, v is EmptyStructGen<int>, false);
-            Eval(11378, v is EmptyStructGen<int>[], false);
-            Eval(11379, v is EmptyStructGen<int>?, false);
-            Eval(11380, v is EmptyStructGen<int>?[], false);
-            Eval(11381, v is NotEmptyStructGen<Guid>, false);
-            Eval(11382, v is NotEmptyStructGen<Guid>[], false);
-            Eval(11383, v is NotEmptyStructGen<Guid>?, false);
-            Eval(11384, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(11385, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(11386, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(11387, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(11388, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(11377, v is EmptyStructGen<int>, false);
+//            Eval(11378, v is EmptyStructGen<int>[], false);
+//            Eval(11379, v is EmptyStructGen<int>?, false);
+//            Eval(11380, v is EmptyStructGen<int>?[], false);
+//            Eval(11381, v is NotEmptyStructGen<Guid>, false);
+//            Eval(11382, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(11383, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(11384, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(11385, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(11386, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(11387, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(11388, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(11389, v is NestedStruct, false);
             Eval(11390, v is NestedStruct[], false);
             Eval(11391, v is NestedStruct?, false);
             Eval(11392, v is NestedStruct?[], false);
-            Eval(11393, v is NestedStructGen<Decimal>, false);
-            Eval(11394, v is NestedStructGen<Decimal>[], false);
-            Eval(11395, v is NestedStructGen<Decimal>?, false);
-            Eval(11396, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11393, v is NestedStructGen<Decimal>, false);
+//            Eval(11394, v is NestedStructGen<Decimal>[], false);
+//            Eval(11395, v is NestedStructGen<Decimal>?, false);
+//            Eval(11396, v is NestedStructGen<Decimal>?[], false);
             Eval(11397, v is ExplicitFieldOffsetStruct, false);
             Eval(11398, v is ExplicitFieldOffsetStruct[], false);
             Eval(11399, v is ExplicitFieldOffsetStruct?, false);
@@ -9259,18 +9259,18 @@ internal class Program
             Eval(11418, v is ImplementTwoInterface[], false);
             Eval(11419, v is ImplementTwoInterface?, false);
             Eval(11420, v is ImplementTwoInterface?[], false);
-            Eval(11421, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(11422, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(11423, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(11424, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(11425, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(11426, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(11427, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(11428, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(11429, v is ImplementAllInterface<int>, false);
-            Eval(11430, v is ImplementAllInterface<int>[], false);
-            Eval(11431, v is ImplementAllInterface<int>?, false);
-            Eval(11432, v is ImplementAllInterface<int>?[], false);
+//            Eval(11421, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(11422, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(11423, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(11424, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(11425, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(11426, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(11427, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(11428, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(11429, v is ImplementAllInterface<int>, false);
+//            Eval(11430, v is ImplementAllInterface<int>[], false);
+//            Eval(11431, v is ImplementAllInterface<int>?, false);
+//            Eval(11432, v is ImplementAllInterface<int>?[], false);
             Eval(11433, v is IntE, false);
             Eval(11434, v is IntE[], false);
             Eval(11435, v is IntE?, false);
@@ -9369,38 +9369,38 @@ internal class Program
             Eval(11528, v is IEmpty[], false);
             Eval(11529, v is INotEmpty, false);
             Eval(11530, v is INotEmpty[], false);
-            Eval(11531, v is IEmptyGen<int>, false);
-            Eval(11532, v is IEmptyGen<int>[], false);
-            Eval(11533, v is INotEmptyGen<int>, false);
-            Eval(11534, v is INotEmptyGen<int>[], false);
+//            Eval(11531, v is IEmptyGen<int>, false);
+//            Eval(11532, v is IEmptyGen<int>[], false);
+//            Eval(11533, v is INotEmptyGen<int>, false);
+//            Eval(11534, v is INotEmptyGen<int>[], false);
             Eval(11535, v is SimpleDelegate, false);
             Eval(11536, v is SimpleDelegate[], false);
-            Eval(11537, v is GenericDelegate<int>, false);
-            Eval(11538, v is GenericDelegate<int>[], false);
+//            Eval(11537, v is GenericDelegate<int>, false);
+//            Eval(11538, v is GenericDelegate<int>[], false);
             Eval(11539, v is EmptyClass, false);
             Eval(11540, v is EmptyClass[], false);
             Eval(11541, v is NotEmptyClass, false);
             Eval(11542, v is NotEmptyClass[], false);
-            Eval(11543, v is EmptyClassGen<int>, false);
-            Eval(11544, v is EmptyClassGen<int>[], false);
-            Eval(11545, v is NotEmptyClassGen<Guid>, false);
-            Eval(11546, v is NotEmptyClassGen<Guid>[], false);
-            Eval(11547, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(11548, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(11543, v is EmptyClassGen<int>, false);
+//            Eval(11544, v is EmptyClassGen<int>[], false);
+//            Eval(11545, v is NotEmptyClassGen<Guid>, false);
+//            Eval(11546, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(11547, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(11548, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(11549, v is NestedClass, false);
             Eval(11550, v is NestedClass[], false);
-            Eval(11551, v is NestedClassGen<Decimal>, false);
-            Eval(11552, v is NestedClassGen<Decimal>[], false);
+//            Eval(11551, v is NestedClassGen<Decimal>, false);
+//            Eval(11552, v is NestedClassGen<Decimal>[], false);
             Eval(11553, v is ImplementOneInterfaceC, false);
             Eval(11554, v is ImplementOneInterfaceC[], false);
             Eval(11555, v is ImplementTwoInterfaceC, false);
             Eval(11556, v is ImplementTwoInterfaceC[], false);
-            Eval(11557, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(11558, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(11559, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(11560, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(11561, v is ImplementAllInterfaceC<int>, false);
-            Eval(11562, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(11557, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(11558, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(11559, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(11560, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(11561, v is ImplementAllInterfaceC<int>, false);
+//            Eval(11562, v is ImplementAllInterfaceC<int>[], false);
             Eval(11563, v is SealedClass, false);
             Eval(11564, v is SealedClass[], false);
         }
@@ -9414,26 +9414,26 @@ internal class Program
             Eval(11570, v is NotEmptyStruct[], false);
             Eval(11571, v is NotEmptyStruct?, false);
             Eval(11572, v is NotEmptyStruct?[], false);
-            Eval(11573, v is EmptyStructGen<int>, false);
-            Eval(11574, v is EmptyStructGen<int>[], false);
-            Eval(11575, v is EmptyStructGen<int>?, false);
-            Eval(11576, v is EmptyStructGen<int>?[], false);
-            Eval(11577, v is NotEmptyStructGen<Guid>, false);
-            Eval(11578, v is NotEmptyStructGen<Guid>[], false);
-            Eval(11579, v is NotEmptyStructGen<Guid>?, false);
-            Eval(11580, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(11581, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(11582, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(11583, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(11584, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(11573, v is EmptyStructGen<int>, false);
+//            Eval(11574, v is EmptyStructGen<int>[], false);
+//            Eval(11575, v is EmptyStructGen<int>?, false);
+//            Eval(11576, v is EmptyStructGen<int>?[], false);
+//            Eval(11577, v is NotEmptyStructGen<Guid>, false);
+//            Eval(11578, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(11579, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(11580, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(11581, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(11582, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(11583, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(11584, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(11585, v is NestedStruct, false);
             Eval(11586, v is NestedStruct[], false);
             Eval(11587, v is NestedStruct?, false);
             Eval(11588, v is NestedStruct?[], false);
-            Eval(11589, v is NestedStructGen<Decimal>, false);
-            Eval(11590, v is NestedStructGen<Decimal>[], false);
-            Eval(11591, v is NestedStructGen<Decimal>?, false);
-            Eval(11592, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11589, v is NestedStructGen<Decimal>, false);
+//            Eval(11590, v is NestedStructGen<Decimal>[], false);
+//            Eval(11591, v is NestedStructGen<Decimal>?, false);
+//            Eval(11592, v is NestedStructGen<Decimal>?[], false);
             Eval(11593, v is ExplicitFieldOffsetStruct, false);
             Eval(11594, v is ExplicitFieldOffsetStruct[], false);
             Eval(11595, v is ExplicitFieldOffsetStruct?, false);
@@ -9450,18 +9450,18 @@ internal class Program
             Eval(11614, v is ImplementTwoInterface[], false);
             Eval(11615, v is ImplementTwoInterface?, false);
             Eval(11616, v is ImplementTwoInterface?[], false);
-            Eval(11617, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(11618, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(11619, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(11620, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(11621, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(11622, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(11623, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(11624, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(11625, v is ImplementAllInterface<int>, false);
-            Eval(11626, v is ImplementAllInterface<int>[], false);
-            Eval(11627, v is ImplementAllInterface<int>?, false);
-            Eval(11628, v is ImplementAllInterface<int>?[], false);
+//            Eval(11617, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(11618, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(11619, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(11620, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(11621, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(11622, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(11623, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(11624, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(11625, v is ImplementAllInterface<int>, false);
+//            Eval(11626, v is ImplementAllInterface<int>[], false);
+//            Eval(11627, v is ImplementAllInterface<int>?, false);
+//            Eval(11628, v is ImplementAllInterface<int>?[], false);
             Eval(11629, v is IntE, false);
             Eval(11630, v is IntE[], false);
             Eval(11631, v is IntE?, false);
@@ -9560,38 +9560,38 @@ internal class Program
             Eval(11724, v is IEmpty[], false);
             Eval(11725, v is INotEmpty, false);
             Eval(11726, v is INotEmpty[], false);
-            Eval(11727, v is IEmptyGen<int>, false);
-            Eval(11728, v is IEmptyGen<int>[], false);
-            Eval(11729, v is INotEmptyGen<int>, false);
-            Eval(11730, v is INotEmptyGen<int>[], false);
+//            Eval(11727, v is IEmptyGen<int>, false);
+//            Eval(11728, v is IEmptyGen<int>[], false);
+//            Eval(11729, v is INotEmptyGen<int>, false);
+//            Eval(11730, v is INotEmptyGen<int>[], false);
             Eval(11731, v is SimpleDelegate, false);
             Eval(11732, v is SimpleDelegate[], false);
-            Eval(11733, v is GenericDelegate<int>, false);
-            Eval(11734, v is GenericDelegate<int>[], false);
+//            Eval(11733, v is GenericDelegate<int>, false);
+//            Eval(11734, v is GenericDelegate<int>[], false);
             Eval(11735, v is EmptyClass, false);
             Eval(11736, v is EmptyClass[], false);
             Eval(11737, v is NotEmptyClass, false);
             Eval(11738, v is NotEmptyClass[], false);
-            Eval(11739, v is EmptyClassGen<int>, false);
-            Eval(11740, v is EmptyClassGen<int>[], false);
-            Eval(11741, v is NotEmptyClassGen<Guid>, false);
-            Eval(11742, v is NotEmptyClassGen<Guid>[], false);
-            Eval(11743, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(11744, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(11739, v is EmptyClassGen<int>, false);
+//            Eval(11740, v is EmptyClassGen<int>[], false);
+//            Eval(11741, v is NotEmptyClassGen<Guid>, false);
+//            Eval(11742, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(11743, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(11744, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(11745, v is NestedClass, false);
             Eval(11746, v is NestedClass[], false);
-            Eval(11747, v is NestedClassGen<Decimal>, false);
-            Eval(11748, v is NestedClassGen<Decimal>[], false);
+//            Eval(11747, v is NestedClassGen<Decimal>, false);
+//            Eval(11748, v is NestedClassGen<Decimal>[], false);
             Eval(11749, v is ImplementOneInterfaceC, false);
             Eval(11750, v is ImplementOneInterfaceC[], false);
             Eval(11751, v is ImplementTwoInterfaceC, false);
             Eval(11752, v is ImplementTwoInterfaceC[], false);
-            Eval(11753, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(11754, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(11755, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(11756, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(11757, v is ImplementAllInterfaceC<int>, false);
-            Eval(11758, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(11753, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(11754, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(11755, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(11756, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(11757, v is ImplementAllInterfaceC<int>, false);
+//            Eval(11758, v is ImplementAllInterfaceC<int>[], false);
             Eval(11759, v is SealedClass, false);
             Eval(11760, v is SealedClass[], false);
         }
@@ -9608,26 +9608,26 @@ internal class Program
             Eval(11766, v is NotEmptyStruct[], false);
             Eval(11767, v is NotEmptyStruct?, false);
             Eval(11768, v is NotEmptyStruct?[], false);
-            Eval(11769, v is EmptyStructGen<int>, false);
-            Eval(11770, v is EmptyStructGen<int>[], false);
-            Eval(11771, v is EmptyStructGen<int>?, false);
-            Eval(11772, v is EmptyStructGen<int>?[], false);
-            Eval(11773, v is NotEmptyStructGen<Guid>, false);
-            Eval(11774, v is NotEmptyStructGen<Guid>[], false);
-            Eval(11775, v is NotEmptyStructGen<Guid>?, false);
-            Eval(11776, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(11777, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(11778, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(11779, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(11780, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(11769, v is EmptyStructGen<int>, false);
+//            Eval(11770, v is EmptyStructGen<int>[], false);
+//            Eval(11771, v is EmptyStructGen<int>?, false);
+//            Eval(11772, v is EmptyStructGen<int>?[], false);
+//            Eval(11773, v is NotEmptyStructGen<Guid>, false);
+//            Eval(11774, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(11775, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(11776, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(11777, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(11778, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(11779, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(11780, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(11781, v is NestedStruct, false);
             Eval(11782, v is NestedStruct[], false);
             Eval(11783, v is NestedStruct?, false);
             Eval(11784, v is NestedStruct?[], false);
-            Eval(11785, v is NestedStructGen<Decimal>, false);
-            Eval(11786, v is NestedStructGen<Decimal>[], false);
-            Eval(11787, v is NestedStructGen<Decimal>?, false);
-            Eval(11788, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11785, v is NestedStructGen<Decimal>, false);
+//            Eval(11786, v is NestedStructGen<Decimal>[], false);
+//            Eval(11787, v is NestedStructGen<Decimal>?, false);
+//            Eval(11788, v is NestedStructGen<Decimal>?[], false);
             Eval(11789, v is ExplicitFieldOffsetStruct, false);
             Eval(11790, v is ExplicitFieldOffsetStruct[], false);
             Eval(11791, v is ExplicitFieldOffsetStruct?, false);
@@ -9644,18 +9644,18 @@ internal class Program
             Eval(11810, v is ImplementTwoInterface[], false);
             Eval(11811, v is ImplementTwoInterface?, true);
             Eval(11812, v is ImplementTwoInterface?[], false);
-            Eval(11813, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(11814, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(11815, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(11816, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(11817, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(11818, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(11819, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(11820, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(11821, v is ImplementAllInterface<int>, false);
-            Eval(11822, v is ImplementAllInterface<int>[], false);
-            Eval(11823, v is ImplementAllInterface<int>?, false);
-            Eval(11824, v is ImplementAllInterface<int>?[], false);
+//            Eval(11813, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(11814, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(11815, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(11816, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(11817, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(11818, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(11819, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(11820, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(11821, v is ImplementAllInterface<int>, false);
+//            Eval(11822, v is ImplementAllInterface<int>[], false);
+//            Eval(11823, v is ImplementAllInterface<int>?, false);
+//            Eval(11824, v is ImplementAllInterface<int>?[], false);
             Eval(11825, v is IntE, false);
             Eval(11826, v is IntE[], false);
             Eval(11827, v is IntE?, false);
@@ -9754,38 +9754,38 @@ internal class Program
             Eval(11920, v is IEmpty[], false);
             Eval(11921, v is INotEmpty, true);
             Eval(11922, v is INotEmpty[], false);
-            Eval(11923, v is IEmptyGen<int>, false);
-            Eval(11924, v is IEmptyGen<int>[], false);
-            Eval(11925, v is INotEmptyGen<int>, false);
-            Eval(11926, v is INotEmptyGen<int>[], false);
+//            Eval(11923, v is IEmptyGen<int>, false);
+//            Eval(11924, v is IEmptyGen<int>[], false);
+//            Eval(11925, v is INotEmptyGen<int>, false);
+//            Eval(11926, v is INotEmptyGen<int>[], false);
             Eval(11927, v is SimpleDelegate, false);
             Eval(11928, v is SimpleDelegate[], false);
-            Eval(11929, v is GenericDelegate<int>, false);
-            Eval(11930, v is GenericDelegate<int>[], false);
+//            Eval(11929, v is GenericDelegate<int>, false);
+//            Eval(11930, v is GenericDelegate<int>[], false);
             Eval(11931, v is EmptyClass, false);
             Eval(11932, v is EmptyClass[], false);
             Eval(11933, v is NotEmptyClass, false);
             Eval(11934, v is NotEmptyClass[], false);
-            Eval(11935, v is EmptyClassGen<int>, false);
-            Eval(11936, v is EmptyClassGen<int>[], false);
-            Eval(11937, v is NotEmptyClassGen<Guid>, false);
-            Eval(11938, v is NotEmptyClassGen<Guid>[], false);
-            Eval(11939, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(11940, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(11935, v is EmptyClassGen<int>, false);
+//            Eval(11936, v is EmptyClassGen<int>[], false);
+//            Eval(11937, v is NotEmptyClassGen<Guid>, false);
+//            Eval(11938, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(11939, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(11940, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(11941, v is NestedClass, false);
             Eval(11942, v is NestedClass[], false);
-            Eval(11943, v is NestedClassGen<Decimal>, false);
-            Eval(11944, v is NestedClassGen<Decimal>[], false);
+//            Eval(11943, v is NestedClassGen<Decimal>, false);
+//            Eval(11944, v is NestedClassGen<Decimal>[], false);
             Eval(11945, v is ImplementOneInterfaceC, false);
             Eval(11946, v is ImplementOneInterfaceC[], false);
             Eval(11947, v is ImplementTwoInterfaceC, false);
             Eval(11948, v is ImplementTwoInterfaceC[], false);
-            Eval(11949, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(11950, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(11951, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(11952, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(11953, v is ImplementAllInterfaceC<int>, false);
-            Eval(11954, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(11949, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(11950, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(11951, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(11952, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(11953, v is ImplementAllInterfaceC<int>, false);
+//            Eval(11954, v is ImplementAllInterfaceC<int>[], false);
             Eval(11955, v is SealedClass, false);
             Eval(11956, v is SealedClass[], false);
         }
@@ -9799,26 +9799,26 @@ internal class Program
             Eval(11962, v is NotEmptyStruct[], false);
             Eval(11963, v is NotEmptyStruct?, false);
             Eval(11964, v is NotEmptyStruct?[], false);
-            Eval(11965, v is EmptyStructGen<int>, false);
-            Eval(11966, v is EmptyStructGen<int>[], false);
-            Eval(11967, v is EmptyStructGen<int>?, false);
-            Eval(11968, v is EmptyStructGen<int>?[], false);
-            Eval(11969, v is NotEmptyStructGen<Guid>, false);
-            Eval(11970, v is NotEmptyStructGen<Guid>[], false);
-            Eval(11971, v is NotEmptyStructGen<Guid>?, false);
-            Eval(11972, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(11973, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(11974, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(11975, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(11976, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(11965, v is EmptyStructGen<int>, false);
+//            Eval(11966, v is EmptyStructGen<int>[], false);
+//            Eval(11967, v is EmptyStructGen<int>?, false);
+//            Eval(11968, v is EmptyStructGen<int>?[], false);
+//            Eval(11969, v is NotEmptyStructGen<Guid>, false);
+//            Eval(11970, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(11971, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(11972, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(11973, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(11974, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(11975, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(11976, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(11977, v is NestedStruct, false);
             Eval(11978, v is NestedStruct[], false);
             Eval(11979, v is NestedStruct?, false);
             Eval(11980, v is NestedStruct?[], false);
-            Eval(11981, v is NestedStructGen<Decimal>, false);
-            Eval(11982, v is NestedStructGen<Decimal>[], false);
-            Eval(11983, v is NestedStructGen<Decimal>?, false);
-            Eval(11984, v is NestedStructGen<Decimal>?[], false);
+//            Eval(11981, v is NestedStructGen<Decimal>, false);
+//            Eval(11982, v is NestedStructGen<Decimal>[], false);
+//            Eval(11983, v is NestedStructGen<Decimal>?, false);
+//            Eval(11984, v is NestedStructGen<Decimal>?[], false);
             Eval(11985, v is ExplicitFieldOffsetStruct, false);
             Eval(11986, v is ExplicitFieldOffsetStruct[], false);
             Eval(11987, v is ExplicitFieldOffsetStruct?, false);
@@ -9835,18 +9835,18 @@ internal class Program
             Eval(12006, v is ImplementTwoInterface[], false);
             Eval(12007, v is ImplementTwoInterface?, true);
             Eval(12008, v is ImplementTwoInterface?[], false);
-            Eval(12009, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(12010, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(12011, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(12012, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(12013, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(12014, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(12015, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(12016, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(12017, v is ImplementAllInterface<int>, false);
-            Eval(12018, v is ImplementAllInterface<int>[], false);
-            Eval(12019, v is ImplementAllInterface<int>?, false);
-            Eval(12020, v is ImplementAllInterface<int>?[], false);
+//            Eval(12009, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(12010, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(12011, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(12012, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(12013, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(12014, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(12015, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(12016, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(12017, v is ImplementAllInterface<int>, false);
+//            Eval(12018, v is ImplementAllInterface<int>[], false);
+//            Eval(12019, v is ImplementAllInterface<int>?, false);
+//            Eval(12020, v is ImplementAllInterface<int>?[], false);
             Eval(12021, v is IntE, false);
             Eval(12022, v is IntE[], false);
             Eval(12023, v is IntE?, false);
@@ -9945,38 +9945,38 @@ internal class Program
             Eval(12116, v is IEmpty[], false);
             Eval(12117, v is INotEmpty, true);
             Eval(12118, v is INotEmpty[], false);
-            Eval(12119, v is IEmptyGen<int>, false);
-            Eval(12120, v is IEmptyGen<int>[], false);
-            Eval(12121, v is INotEmptyGen<int>, false);
-            Eval(12122, v is INotEmptyGen<int>[], false);
+//            Eval(12119, v is IEmptyGen<int>, false);
+//            Eval(12120, v is IEmptyGen<int>[], false);
+//            Eval(12121, v is INotEmptyGen<int>, false);
+//            Eval(12122, v is INotEmptyGen<int>[], false);
             Eval(12123, v is SimpleDelegate, false);
             Eval(12124, v is SimpleDelegate[], false);
-            Eval(12125, v is GenericDelegate<int>, false);
-            Eval(12126, v is GenericDelegate<int>[], false);
+//            Eval(12125, v is GenericDelegate<int>, false);
+//            Eval(12126, v is GenericDelegate<int>[], false);
             Eval(12127, v is EmptyClass, false);
             Eval(12128, v is EmptyClass[], false);
             Eval(12129, v is NotEmptyClass, false);
             Eval(12130, v is NotEmptyClass[], false);
-            Eval(12131, v is EmptyClassGen<int>, false);
-            Eval(12132, v is EmptyClassGen<int>[], false);
-            Eval(12133, v is NotEmptyClassGen<Guid>, false);
-            Eval(12134, v is NotEmptyClassGen<Guid>[], false);
-            Eval(12135, v is NotEmptyClassConstrainedGen<object>, false);
-            Eval(12136, v is NotEmptyClassConstrainedGen<object>[], false);
+//            Eval(12131, v is EmptyClassGen<int>, false);
+//            Eval(12132, v is EmptyClassGen<int>[], false);
+//            Eval(12133, v is NotEmptyClassGen<Guid>, false);
+//            Eval(12134, v is NotEmptyClassGen<Guid>[], false);
+//            Eval(12135, v is NotEmptyClassConstrainedGen<object>, false);
+//            Eval(12136, v is NotEmptyClassConstrainedGen<object>[], false);
             Eval(12137, v is NestedClass, false);
             Eval(12138, v is NestedClass[], false);
-            Eval(12139, v is NestedClassGen<Decimal>, false);
-            Eval(12140, v is NestedClassGen<Decimal>[], false);
+//            Eval(12139, v is NestedClassGen<Decimal>, false);
+//            Eval(12140, v is NestedClassGen<Decimal>[], false);
             Eval(12141, v is ImplementOneInterfaceC, false);
             Eval(12142, v is ImplementOneInterfaceC[], false);
             Eval(12143, v is ImplementTwoInterfaceC, false);
             Eval(12144, v is ImplementTwoInterfaceC[], false);
-            Eval(12145, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
-            Eval(12146, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
-            Eval(12147, v is ImplementTwoInterfaceGenC<int>, false);
-            Eval(12148, v is ImplementTwoInterfaceGenC<int>[], false);
-            Eval(12149, v is ImplementAllInterfaceC<int>, false);
-            Eval(12150, v is ImplementAllInterfaceC<int>[], false);
+//            Eval(12145, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>, false);
+//            Eval(12146, v is ImplementOneInterfaceGenC<EmptyStructGen<int>>[], false);
+//            Eval(12147, v is ImplementTwoInterfaceGenC<int>, false);
+//            Eval(12148, v is ImplementTwoInterfaceGenC<int>[], false);
+//            Eval(12149, v is ImplementAllInterfaceC<int>, false);
+//            Eval(12150, v is ImplementAllInterfaceC<int>[], false);
             Eval(12151, v is SealedClass, false);
             Eval(12152, v is SealedClass[], false);
         }
@@ -9990,26 +9990,26 @@ internal class Program
             Eval(12158, v is NotEmptyStruct[], false);
             Eval(12159, v is NotEmptyStruct?, false);
             Eval(12160, v is NotEmptyStruct?[], false);
-            Eval(12161, v is EmptyStructGen<int>, false);
-            Eval(12162, v is EmptyStructGen<int>[], false);
-            Eval(12163, v is EmptyStructGen<int>?, false);
-            Eval(12164, v is EmptyStructGen<int>?[], false);
-            Eval(12165, v is NotEmptyStructGen<Guid>, false);
-            Eval(12166, v is NotEmptyStructGen<Guid>[], false);
-            Eval(12167, v is NotEmptyStructGen<Guid>?, false);
-            Eval(12168, v is NotEmptyStructGen<Guid>?[], false);
-            Eval(12169, v is NotEmptyStructConstrainedGen<IntPtr>, false);
-            Eval(12170, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
-            Eval(12171, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
-            Eval(12172, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
+//            Eval(12161, v is EmptyStructGen<int>, false);
+//            Eval(12162, v is EmptyStructGen<int>[], false);
+//            Eval(12163, v is EmptyStructGen<int>?, false);
+//            Eval(12164, v is EmptyStructGen<int>?[], false);
+//            Eval(12165, v is NotEmptyStructGen<Guid>, false);
+//            Eval(12166, v is NotEmptyStructGen<Guid>[], false);
+//            Eval(12167, v is NotEmptyStructGen<Guid>?, false);
+//            Eval(12168, v is NotEmptyStructGen<Guid>?[], false);
+//            Eval(12169, v is NotEmptyStructConstrainedGen<IntPtr>, false);
+//            Eval(12170, v is NotEmptyStructConstrainedGen<IntPtr>[], false);
+//            Eval(12171, v is NotEmptyStructConstrainedGen<IntPtr>?, false);
+//            Eval(12172, v is NotEmptyStructConstrainedGen<IntPtr>?[], false);
             Eval(12173, v is NestedStruct, false);
             Eval(12174, v is NestedStruct[], false);
             Eval(12175, v is NestedStruct?, false);
             Eval(12176, v is NestedStruct?[], false);
-            Eval(12177, v is NestedStructGen<Decimal>, false);
-            Eval(12178, v is NestedStructGen<Decimal>[], false);
-            Eval(12179, v is NestedStructGen<Decimal>?, false);
-            Eval(12180, v is NestedStructGen<Decimal>?[], false);
+//            Eval(12177, v is NestedStructGen<Decimal>, false);
+//            Eval(12178, v is NestedStructGen<Decimal>[], false);
+//            Eval(12179, v is NestedStructGen<Decimal>?, false);
+//            Eval(12180, v is NestedStructGen<Decimal>?[], false);
             Eval(12181, v is ExplicitFieldOffsetStruct, false);
             Eval(12182, v is ExplicitFieldOffsetStruct[], false);
             Eval(12183, v is ExplicitFieldOffsetStruct?, false);
@@ -10026,18 +10026,18 @@ internal class Program
             Eval(12202, v is ImplementTwoInterface[], false);
             Eval(12203, v is ImplementTwoInterface?, false);
             Eval(12204, v is ImplementTwoInterface?[], false);
-            Eval(12205, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
-            Eval(12206, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
-            Eval(12207, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
-            Eval(12208, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
-            Eval(12209, v is ImplementTwoInterfaceGen<int>, false);
-            Eval(12210, v is ImplementTwoInterfaceGen<int>[], false);
-            Eval(12211, v is ImplementTwoInterfaceGen<int>?, false);
-            Eval(12212, v is ImplementTwoInterfaceGen<int>?[], false);
-            Eval(12213, v is ImplementAllInterface<int>, false);
-            Eval(12214, v is ImplementAllInterface<int>[], false);
-            Eval(12215, v is ImplementAllInterface<int>?, false);
-            Eval(12216, v is ImplementAllInterface<int>?[], false);
+//            Eval(12205, v is ImplementOneInterfaceGen<EmptyStructGen<int>>, false);
+//            Eval(12206, v is ImplementOneInterfaceGen<EmptyStructGen<int>>[], false);
+//            Eval(12207, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?, false);
+//            Eval(12208, v is ImplementOneInterfaceGen<EmptyStructGen<int>>?[], false);
+//            Eval(12209, v is ImplementTwoInterfaceGen<int>, false);
+//            Eval(12210, v is ImplementTwoInterfaceGen<int>[], false);
+//            Eval(12211, v is ImplementTwoInterfaceGen<int>?, false);
+//            Eval(12212, v is ImplementTwoInterfaceGen<int>?[], false);
+//            Eval(12213, v is ImplementAllInterface<int>, false);
+//            Eval(12214, v is ImplementAllInterface<int>[], false);
+//            Eval(